Service contract software: the month is over, and only now do you know if it made money

The owner of a multi-service company near Padua, 140 employees and 6.8 million euros in revenue, gets the same sheet from his accountant every month. Thirty-one rows, one per contract, with revenue and costs for the previous month. The sheet arrives on the twentieth, and the labour costs are those of the last closed payslip. By the time he reads it, the month it describes ended three weeks ago and the next one is already half over.

Here you will find what "contract management software" really means when you execute the contract and do not award it, the single number that tells you whether a system will make you money or just give you a tidier spreadsheet, the cost today of running service contracts on spreadsheets, payslips and the memory of your site coordinators, two calculations written in code that you can redo with your own data, and the threshold above which a custom-built piece pays for itself. The case that follows is a typical one, rebuilt from situations I have seen in service companies, with rounded numbers.

What contract management software is, and what it is not

The search "contract management software" hides three different people, and whoever buys the wrong tool finds out when the system does not answer the question they had in mind. It is worth separating them right away.

The first is the contracting authority: a municipality, a health authority, a public company. For them, contract software means running tenders, scoring bids and monitoring the execution of the contracts they awarded. It is a world of procurement platforms, governed by the Public Contracts Code and by digitalisation obligations, and this article is not about it.

The second is the company that bids for tenders: it looks for calls, prepares documentation, tracks bid deadlines. Good services and products exist for this, and they are almost always off-the-shelf products, not custom builds.

The third is the company that executes contracts: cleaning, grounds maintenance, facility management, security, catering, internal logistics, plant maintenance on behalf of others. It wins or renews a contract and then has to deliver it with people, vehicles and materials, so that a margin is left at the end. This article is about that company, and it is the one that most often discovers it has a problem when it already costs a lot.

A service contract is not a job order and not a contract document

The words get mixed up, and the difference matters for the software. A job order has a start, an end and a final margin: I covered it in the article on job costing software. A contract has a term and deadlines you must not forget, the subject of contract management software. A service contract is a third thing: it lasts years, has a fee or an hourly price, has a specification that says how many hours and which services, and it produces margin day by day, not at the end.

This changes the basic question. On a job order you ask whether you will close at a profit. On a service contract you ask whether this month, on this contract, you are making money, and you want to know while you can still fix the team, not three months later.

What it must do, one line per function

A system that is useful to whoever executes contracts holds together five things: the contract with its specification and clauses, the hours and services actually delivered, the real cost of the people who delivered them, the margin per contract updated quickly, and the deadlines that move money, such as renewal, price revision, compliance documents and guarantees. Every management system on the market does one or two of these well. Almost none keeps all five in the same place, and that is where the sheet of the twentieth comes from.

Why a contract loses margin without anyone noticing

At the Padua company nobody was doing their job badly. The coordinators organised the teams, the payroll office closed the payslips, accounting invoiced on time. Every piece worked. What did not work was the time between an hour worked and the moment someone understood what it had cost.

We measured it. An hour of cleaning done on the 3rd entered the attendance records that evening, the payslip on the 10th of the next month, the contract cost on the 15th, and the margin sheet on the 20th. An hour done on the 28th waited less, but on average the distance was sixty-two days between the work and the first time the margin of that work appeared in writing anywhere.

Sixty-two days is a problem for a precise reason. On a service contract the margin is decided by hours: how many you put in, at what cost, against how many the client pays for. If a team is oversized by two people, every day of delay in noticing is a day of margin burned, and there is no way to recover it later.

The three things that hide for two months

The first is hours drift. A contract starts with the right team. Then one person is ill, a replacement is added, the client asks for one extra task, the replacement stays. After six months the team has an hour and a half a day more than the specification allows, and none of the decisions taken was wrong on its own.

The second is cost moving under the price. When the national collective labour agreement (CCNL) is renewed, the hourly cost goes up, and the contract price, unless a clause is triggered, stays the same. Every month the gap eats margin, and no sheet shows it until someone redoes the whole calculation.

The third is the service not requested in writing but delivered. The client asks for something extra by word of mouth, the coordinator says yes to keep the relationship good, nobody puts it in writing and nobody invoices it. It is generosity in week one and habit by week ten.

All three are visible in a day if the data is in order, and they take two months to show if the data arrives in pieces. That is the difference contract management software must make, and the reason the word that matters is not "management" but timeliness.

Public and private contracts: where the problem changes

In public contracts the specification is precise, hours and services are written down, the client's checks are formal and penalties come from a table. Here the risk is excess rigidity: a service is disputed and you must prove you delivered it, with dates, times and people. Whoever does not have the records at hand pays the penalty even when they were right.

In private contracts the specification is often vaguer and the relationship more personal. The risk is the opposite: extra requests pile up without any being formalised, and when the contract expires the client considers everything you have always done to be normal. The deciding number is the same, but the way of losing margin changes.

The real cost: what it costs today to run contracts on spreadsheets, payslips and coordinators' memory

Before talking about software, do the sum for today's situation. In the Padua case there were five items. I give them with the method, so you can redo it with your own numbers.

Hours delivered and not paid for. Comparing the hours actually worked with those in the specifications, on twelve contracts the difference had been stable, in excess, for at least six months. In all, about 2,900 hours a year of services requested by the client and granted with no paperwork and no extra fee. At a full hourly cost of 21 euros that is about 61,000 euros a year. Not all of it was billable, but for half of it a single line in a meeting minute would have done.

Adjustments never requested. Four contracts, with a combined value of 1.6 million a year, had a price adjustment clause. After the collective agreement renewal the cost of labour had gone up, and nobody had done the calculation to ask for the revision. Assuming a conservative recovery of 2.4 percent of the value of those contracts, that is about 38,000 euros a year left on the table.

Loss-making contracts found late. Three contracts, 1.1 million euros a year, had a real margin five points below the bid price margin. They were found after seven months. With the team corrected in the first month, at least half of the loss would have been avoided: about 28,000 euros.

Penalties suffered without being able to dispute them. Nine client complaints, with penalties applied totalling 21,000 euros. In five cases the disputed service had been delivered, but nobody could produce the record with times and names in time. The direct cost is about 21,000 euros, plus the time lost arguing.

Office time spent rebuilding. Two administrators and three coordinators spent on average five hours a week putting together attendance, payslips, material orders and client reports. Five hours for forty-six weeks for five people makes 1,150 hours, which at 38 euros an hour is about 44,000 euros.

The total is about 192,000 euros a year, 2.8 percent of revenue, in a company with an operating margin of 4.5 percent. Put another way: more than half of the profit was leaking out through the way contracts were followed, not through the price or the quality of the service.

Your sum will be different, but the items are almost always these five. If the total, redone with your numbers, is below 0.7 percent of revenue, contract management software is not your priority. If it exceeds 1.5, it almost certainly is, even if nobody in the company calls it that.

Margin age: the number that decides

The five-item sum tells you how much you lose. It does not tell you whether software will get that money back, because part of the losses depends on commercial decisions that no program makes for you. The number that tells you is another one, and I call it margin age: the average, weighted by revenue, of the days between the end of the month of work and the moment the margin of each contract, for that month, is written down and readable by whoever decides.

I use four thresholds. Under fifteen days the situation is under control: a well-kept spreadsheet is enough, and maybe not even that. Between fifteen and forty-five the problem is one of method: the data is there but arrives in scattered order, and before software you need to decide who delivers what and when. Between forty-five and ninety a system that calculates on its own pays for itself, because the delay is structural and no discipline removes it. Beyond ninety days you are driving blind: you are in a company where the margin is known only at year-end accounts.

At the Padua company margin age was sixty-two days, in the band where a system pays for itself. And the distribution said more than the average: the three contracts with the hidden loss were all among those with the highest labour cost, and their margin appeared on average after seventy-one days.

How to calculate it, with the data you have

You do not need a new system for the first measurement. You need a table that says, for each contract and each month, on which day the margin was calculated for the first time. If it does not exist, rebuild it from files: the save date of each month's margin sheet, or the date of the email that delivered it to management. With that date the measurement is a query.

-- Margin age: average days, weighted by revenue, between the end of the month of work
-- and the first day the margin of that contract for that month was written down.
-- Last twelve closed months.
WITH Mesi AS (
    SELECT m.IdAppalto,
           m.Mese,                                   -- first day of the month of work
           EOMONTH(m.Mese) AS FineMese,
           m.DataCalcolo,                            -- when the margin was first written down
           m.Ricavi
    FROM AppaltiMargini AS m
    WHERE m.Mese >= DATEADD(month, -12, DATEFROMPARTS(YEAR(GETDATE()), MONTH(GETDATE()), 1))
      AND m.Mese <  DATEFROMPARTS(YEAR(GETDATE()), MONTH(GETDATE()), 1)
)
SELECT a.Nome,
       COUNT(*) AS MesiMisurati,
       CAST(SUM(1.0 * DATEDIFF(day, x.FineMese, x.DataCalcolo) * x.Ricavi)
            / NULLIF(SUM(x.Ricavi), 0) AS decimal(6, 1)) AS EtaMargineGiorni
FROM Mesi AS x
JOIN Appalti AS a ON a.IdAppalto = x.IdAppalto
GROUP BY a.Nome
ORDER BY EtaMargineGiorni DESC;

The query returns the age per contract; the company figure is the revenue-weighted average of all rows. Two warnings. First: if the margin of individual contracts has never been calculated and there is only the company margin, the measurement is already a result, and an ugly one: by definition it means an age above ninety days. Second: do not count the date when someone looked at the sheet, but the date when the number existed. They are different days, and the second is the one that counts.

The second number: how far each contract drifts from the specification

Next to margin age I measure a second number: for each contract, the hours actually delivered against the hours in the specification, month by month. It is the early signal. The margin tells you something is wrong, the drift tells you where, and it tells you before the payslip closes.

The bands are less rigid, but a contract with a stable overrun above four percent for three months almost always has one of the three causes from before: team drift, an unformalised service, replacements that have become structural. It is the list to look at every Monday.

Contract hours: what is calculated, and with what data

Almost all the value of contract management software sits in a single function: putting side by side, every day, three numbers that today live in three different places. The hours in the specification, the hours delivered that come from attendance, and the real hourly cost of those who delivered them, which comes from payroll.

The first is written by the contract, and it goes in once, with the clauses that go with it. The second already exists, if the company has attendance tracking: I covered it in the article on time and attendance software, and the point here is that clock-ins must arrive with the contract code, not just the person's name. The third is estimated each month from the group's average hourly cost and corrected when the payslips arrive.

With these three numbers the margin of a contract can be estimated every day, with an approximation that after a few months of calibration stays within one and a half points of the value that will come out at month end. It is not the final margin. It is a margin right enough, in time, which is worth more than a perfect margin that is late.

A calculation you write in an hour

The simplest and most useful calculation is the estimate of each contract's margin at mid-month, with the data you have. Here it is in C#, with minimal types.

// Mid-month margin estimate for a contract, without waiting for the payslips.
public sealed record Appalto(string Codice, string Nome, decimal CanoneMensile, decimal OreCapitolatoMese);

public sealed record LavoroGiorno(string CodiceAppalto, DateOnly Giorno, decimal Ore, decimal CostoOrario);

public sealed record StimaMargine(
    string Codice,
    decimal RicaviAttesi,
    decimal CostoStimato,
    decimal MargineStimato,
    decimal MarginePercentuale,
    decimal ScostamentoOrePercentuale);

public static class StimeAppalti
{
    public static IReadOnlyList<StimaMargine> Calcola(
        IEnumerable<Appalto> appalti, IEnumerable<LavoroGiorno> lavoro,
        DateOnly oggi, decimal costiIndiretti = 0.06m)
    {
        var giorniMese = DateTime.DaysInMonth(oggi.Year, oggi.Month);
        var trascorso = (decimal)oggi.Day / giorniMese;
        var delMese = lavoro.Where(l => l.Giorno.Year == oggi.Year && l.Giorno.Month == oggi.Month).ToList();

        return appalti.Select(a =>
        {
            var righe = delMese.Where(l => l.CodiceAppalto == a.Codice).ToList();
            var ore = righe.Sum(l => l.Ore);
            var costo = righe.Sum(l => l.Ore * l.CostoOrario);

            // The fee is monthly: it accrues in proportion to the days elapsed.
            var ricavi = a.CanoneMensile * trascorso;
            var indiretti = ricavi * costiIndiretti;
            var margine = ricavi - costo - indiretti;
            var orePreviste = a.OreCapitolatoMese * trascorso;
            var scostamento = orePreviste == 0 ? 0 : (ore - orePreviste) / orePreviste * 100;

            return new StimaMargine(
                a.Codice,
                Math.Round(ricavi, 0),
                Math.Round(costo + indiretti, 0),
                Math.Round(margine, 0),
                ricavi == 0 ? 0 : Math.Round(margine / ricavi * 100, 1),
                Math.Round(scostamento, 1));
        })
        .OrderBy(s => s.MarginePercentuale)
        .ToList();
    }
}

Take a cleaning contract for a school campus with a fee of 9,400 euros a month and 410 planned hours. If by day fifteen the hours delivered are 226 against 205 expected and the average hourly cost is 20.80 euros, the calculation returns an estimated margin of just 7.1 percent against the 11 percent of the bid, and an hours drift of 10.2 percent. It is the signal that the team has grown. It arrives mid-month instead of at year-end.

There is nothing sophisticated here, and that is the point. The value is not in the formula: it is in the fact that it runs every night on real data and that the list, sorted by margin, reaches the right coordinator as something to look at, not a report to read.

Price revision and labour cost adjustment: the calculation nobody does alone

In labour-intensive services, the cost of labour weighs between seventy and eighty-five percent of the cost of the contract. When the collective agreement is renewed, the hourly cost rises across the board. If the price does not adjust, the margin shrinks by almost as much, every month, for the whole life of the contract.

In public contracts the Public Contracts Code provides, in article 60 of D.Lgs. 36/2023, price revision clauses that trigger when the change in costs exceeds a threshold, set at five percent, and compensate a share of the excess, eighty percent. It is the way the law today rebalances long-term contracts. I read it with caution and I invite you to do the same: what counts is the text of your contract and your clause, not my summary. In private contracts the clause is either there or not, and if it is there it has its own rules.

The part that matters for software is another one: the clause does not trigger by itself. Someone must notice that the threshold has been passed, calculate the change with the index provided, write the request within the deadlines, and attach the calculations. In the Padua case nobody had this task, and four contracts with a valid clause had lost months of adjustment.

The calculation, with the rules that hold

// What is due if the clause triggers above a threshold and compensates a share of the excess.
// Threshold and share come from the contract, not from the code: here they are parameters.
public sealed record ClausolaRevisione(decimal SogliaPercentuale, decimal QuotaCompensata);

public sealed record RichiestaRevisione(
    decimal VariazionePercentuale,
    bool SogliaSuperata,
    decimal ImportoAnnuoRecuperabile);

public static class Revisioni
{
    public static RichiestaRevisione Calcola(
        decimal costoOrarioBase, decimal costoOrarioAttuale,
        decimal quotaManodopera, decimal importoAnnuo, ClausolaRevisione clausola)
    {
        // Change in the cost of the contract due to labour alone.
        var variazioneOrario = (costoOrarioAttuale - costoOrarioBase) / costoOrarioBase * 100;
        var variazione = variazioneOrario * quotaManodopera;

        if (variazione <= clausola.SogliaPercentuale)
        {
            return new RichiestaRevisione(Math.Round(variazione, 2), false, 0m);
        }

        // Only the part above the threshold is compensated, in the share provided.
        var eccedenza = variazione - clausola.SogliaPercentuale;
        var recuperabile = importoAnnuo * (eccedenza / 100) * clausola.QuotaCompensata;
        return new RichiestaRevisione(Math.Round(variazione, 2), true, Math.Round(recuperabile, 0));
    }
}

With an hourly cost that went from 19.60 to 21.40 euros, a labour share of eighty percent, a contract worth 380,000 euros a year and a clause with a five percent threshold and eighty percent compensation, the change is 7.3 percent, the threshold is exceeded and the recoverable request is about 6,900 euros a year. Multiplied by four similar contracts, we are close to the 38,000 euros from before.

One rule matters more than the formula: the system must warn when the threshold is near, not when it has already passed, and it must hold the date by which the request has to be filed. An adjustment filed late cannot be recovered, and the date is often lost because it sits in a contract nobody reopens.

The clauses to read once and remember always

Every contract has five or six clauses that move money: the term and extension options, price revision, penalties and how they are disputed, the increase or decrease of services within one fifth, the rules on subcontracting, the performance guarantee. You do not need fifty fields: you need these, entered properly, with the date on which each becomes important. An afternoon of work per contract, done once, which the system then reminds you of at the right moment.

How contract management software should run: from specification to invoice

The question I am asked most often is whether it should be a product or a new system. First it helps to understand what has to happen, because the flow is the same whichever road you choose.

The specification goes in once. Hours per service, fee, term, penalties, clauses. It is not retyped into every sheet: it lives in the system and everything else reads it.

Attendance arrives with the contract code. Every clock-in or shift row carries the site or location. It is the point where most time is lost today, because payroll knows the person and not the contract. At the Padua company it was enough to change the shift sheet for the data to arrive right.

The real hourly cost is adjusted with payroll. The daily estimate uses the group's average cost. When the payslips arrive, the estimate is replaced with the true value. The margin changes little, and you learn by how much: after six months the average error falls below one and a half points.

Every morning, the list of contracts from worst. With estimated margin, hours drift and the latest team change. The coordinator reads it for their own group and the owner reads it once a week. It is the page that replaces the sheet of the twentieth.

Services outside the specification are written down immediately. When the client asks for something extra, the coordinator records it from the phone in one line: what, when, how many hours. At month end the system proposes what to invoice as an extra and what the client has already approved in writing.

The record to dispute penalties is already ready. For every service delivered there are date, time and people. When a complaint arrives, the extract is produced in a minute, not in three days.

None of these steps requires changing payroll or invoicing. At the Padua company the payroll and accounting programs stayed the same. What changed was what sat in between: the margin sheet and the coordinators' memory.

Subcontracts, compliance and deadlines that do not produce margin

Good contract management software also holds the things that do not earn money but avoid serious trouble. If part of the service is given to a subcontractor, you need to check their contribution compliance, the single compliance certificate (DURC), with its expiry, the client's authorisation when needed, and the suitability of those working on someone else's premises. These are the same themes as construction site management software, with one difference: here they do not end with the site, they last as long as the contract.

The same goes for safety. Every employee working at a client's site must have medical fitness, training and equipment in order for that task. I cover it in the article on health and safety software: the point here is that the requirement and the contract sit in the same system, so an assignment to a site is blocked if a document is missing, before the client notices.

What contract management software costs: vertical product, ERP module or custom

There are three roads, and the prices that follow are those I see in 2026 for Italian service companies with revenue between three and thirty million euros.

The vertical product for service companies. Programs exist designed for cleaning, multi-service and facility management. They usually cost between 3,000 and 20,000 euros a year, depending on users and modules, with a setup between zero and 15,000 euros. They do the typical things of the sector well, such as shifts, sites and material orders. They do less well the things particular to your company: the link to your payroll, the clauses of your contracts, the margin estimated at mid-month.

The ERP module. The job order module of the accounting system costs between 8,000 and 30,000 euros in licence and configuration. It has the advantage of already knowing costs and invoices. It is designed for job orders that end, not for contracts that last five years with fees and hours, and you can tell when you try to put a specification into it.

The custom system. Here too, two figures. A custom piece that sits alongside what you have, meaning the link to attendance and payroll, the daily margin estimate, the clauses with their dates and the dispute record, costs between 30,000 and 60,000 euros, plus fifteen or twenty percent a year for maintenance. A complete system that replaces everything costs between 90,000 and 180,000 euros, and is rarely needed below fifty contracts.

The threshold, with numbers

The most useful comparison is between the vertical product with margin rebuilt by hand by an administrator, and the same product paired with a custom link. The product cost is the same in both cases, so you compare two things: the time to rebuild by hand, which grows with the number of contracts, and the cost of the custom piece, which is almost fixed.

With the Padua numbers, rebuilding the margin of one contract by hand cost about nine hours a month between data collection and checks. Over five years, counting the custom piece at 42,000 euros plus maintenance, the two lines cross at around fifteen active contracts. Below that threshold an attentive administrator and a good spreadsheet are enough. Above it, every extra contract adds hours nobody has.

And time alone is the smallest part of the bill. Adding the extra hours invoiced, the adjustments recovered, the loss corrected in time and the penalties disputed with evidence, at Padua the custom piece, which cost 46,000 euros with the service record, paid for itself in eleven months, and the threshold drops to six or seven contracts.

The road I recommend in most cases is a mixed one: a vertical product or the ERP module for shifts, sites and accounting, and a custom piece for what no product does well, meaning the margin estimated every day, the clauses with dates and the service record. If the whole company has fewer than six or seven contracts, you need neither: a good spreadsheet and an hour a week are enough.

The questions to ask whoever proposes a product

Five questions separate the products that solve the problem from those that move it.

Do I see a contract's margin at mid-month or at month end? Ask to see a contract with the margin estimated at day fifteen. If the answer is "after payroll closes", margin age will stay what it is today.

Does attendance arrive with the contract code? If the program knows people but not contracts, the link will be a file to import by hand, forever.

Where do the clauses live, and who warns me when they trigger? If they are a free-text field, nobody will ever warn you.

How do I record an out-of-specification service from the phone? If it takes a computer and five minutes, nobody will do it.

How does my data get out? A product that does not expose its data through a documented interface is another island, and the cost of a contract is the last piece of information a service company can afford to leave locked inside a supplier's program.

Artificial intelligence in contract management software: where it helps and where it does not

Many 2026 products promise an assistant based on artificial intelligence. I have used language models daily in my work since 2023, and for those who execute contracts I have seen three uses that pay off and one that does not.

Reading the specification. A model reads the tender document and proposes the contract sheet: term, extension options, penalties, revision clause, guarantees, hours per service. A person checks and confirms. An afternoon's work becomes twenty minutes, and above all the clauses end up in the system instead of in an attachment.

The draft of the request. When the revision threshold is passed, the model prepares the letter with the calculations, the index used and the contract references. The signature is a person's and the numbers are those calculated by the system, not invented by the model.

The minute of the extra service. The coordinator dictates thirty seconds after the client's request, "the director wants the special cleaning of the atrium every Friday, three hours, two people", and finds the service recorded, with a proposal on how to invoice it.

What does not pay off is the automatic prediction of who will win a tender or of the right price to offer, because it depends on factors the model does not see, such as competitors' strategy and the relationship with the client.

The rule is the same one I apply everywhere: artificial intelligence prepares, the person decides. A model that writes an adjustment request with the wrong index, with great confidence, is worse than no model.

Where to start: the first release in ninety days

Whether you choose a product, the ERP module or a custom piece, the order in which you do things matters more than the choice. This is the plan I use for a service company, and it fits in ninety days.

The first two weeks: the measurement. You calculate margin age with the dates you can rebuild. You compare hours delivered and hours planned for the last six months across all contracts. You redo the five-item sum. At the end you have a number and a list of the contracts to look at first.

Weeks three to six: the specification and the code. You enter the contracts with their important clauses into the system, and you add the contract code to every shift sheet, so that attendance arrives right. You start with the largest contracts and the three with the worst margin.

Weeks seven to ten: the daily estimate. You switch on the mid-month margin calculation and the sorted morning list. The coordinators watch it for a month in parallel with the spreadsheet, and you calibrate the error against the real payslips. It is the phase where illusions are lost and trust is gained.

The last three weeks: clauses and services. You switch on the alerts on revisions and deadlines, and the record of out-of-specification services from the phone. From here on the data is created once.

The rest, from reading specifications to drafting letters, comes later, when the data is reliable. A model working on incomplete data writes wrong drafts with great confidence, and people stop trusting it in a day.

If the number says it is not your problem

It may be that, once you measure, margin age is under fifteen days, hours differ little from the specification and someone follows the clauses. That is good news, and it is worth saying clearly: in that case custom contract management software is not for you, and whoever tells you otherwise is selling you something.

In that case the bottleneck, if there is one, is almost always elsewhere. If margins are known but low, the problem is in the bid price, and no software solves it: you solve it by redoing the numbers before the next tender, with the true hourly cost. If the team is right but turnover is high, the problem is in working conditions, and a program does not change that either.

And there is one case where software is not the answer even with bad numbers: when contracts are few and large, one or two worth half the revenue. There you need a management controller who spends half a day a week on it, not a system.

If you have read this far, you probably have the sheet of the twentieth in mind. Before watching any demo, take your three largest contracts and write down, for the last closed month, the day on which you were first able to say how much you had earned. If it is more than forty-five days, you already have your answer. The rest is a project, not a product choice.

If you want a second look at your case, the way is software consulting, and when the right solution is a piece built around the way you work, and the same page also covers custom software. For the method used to read the margin of a whole company, from above, there is the article on management control software.