Contract management software: a rack paid for three more years, and the cancellation notice was sitting in a mailbox

In March the head of administration at an IT and telephony services company near Treviso, ninety five employees, received an invoice nobody was expecting: the first fee of another thirty six months for a rack in a data centre that the company had emptied two years earlier, when it moved everything to the cloud. The contract renewed itself, notice had to be sent one hundred and eighty days before expiry, that is by the first of September, and the signed PDF was sitting in the mailbox of a partner who had left the company. One thousand one hundred and fifty euros a month for three years: forty one thousand euros spent for not knowing a date. If you have wondered whether you need contract management software, this article gives you a way to answer with a number instead of a feeling.

You will find the real cost of contracts kept today across shared folders, mailboxes and spreadsheets, the single number that tells you whether contract management software will give you margin back or only a tidier archive, why the heart of the project is not the PDF but the clause, the three dates that really make money and the Italian rules that govern them, where artificial intelligence helps you load a thousand contracts and where it gets things dangerously wrong, the real price ranges between the module of the ERP you already have, a dedicated product and a custom system, and the number of contracts beyond which the maths changes.

I have been writing software since 1999, and I have a particular relationship with contracts: for years I built and then sold a product for law firms, used by many organisations, and a good part of the work was precisely turning texts written to be signed into data you could make decisions on. I have seen the same scene in very different companies: service firms with a thousand support contracts, distributors with price lists tied to indices, businesses that pay rents, licences and insurance without knowing when they could stop paying them. A contract is signed with great care and then forgotten, and from that moment on it is the contract that decides.

What I have learned, and what explains why so many companies buy a beautiful document archive and a year later are still paying renewals they did not want, is this: the number that decides is not how many contracts you have archived, it is how much of the value of your contracts does not have, in a system, the next date on which you can still decide something. A contract whose last notice date you know is a contract you can renegotiate. A contract whose date you only know by opening the PDF, if you remember to open it, is a contract that renews, adjusts or is lost without you. If that share is high, a good system brings it down within a few months and pays for itself. If it is already low, you are buying convenience, and it should be bought from a different budget.

What contract management software is, and what it is not

Contract management software is the system that holds, for each of the company's contracts, four things that today live in four different places: what you promised and what you were promised, until when and on what terms it renews, how the price changes over time, and what needs to happen in the coming months for the contract to remain your decision. If one of those four is missing, you do not have contract management software: you have a list of files.

The difference from an archive is not one of degree, it is one of kind. An archive keeps a document: contract number 2019/114 with the data centre, signed on the first of March 2020, twelve pages plus a technical annex. Contract management software turns that document into facts you can act on: it renews automatically for periods of thirty six months, the notice period is one hundred and eighty days, notice must be sent by certified email, the last useful day is the first of September 2025, the fee is adjusted every year by one hundred per cent of the consumer price index and the last adjustment applied dates back to 2022. Everyone will sell you the archive. Nobody sells you the second thing: it depends on information you already have, written in legal language, that nobody has ever pulled out of the text.

Sales contracts and purchase contracts: two problems with the same name

The confusion here is expensive, because you end up buying the tool for a different problem. Sales contracts are the ones through which you sell: support, recurring fees, subscriptions, maintenance, ongoing supplies. The risk is in revenue: price adjustments you do not apply, services you deliver outside what was agreed and do not invoice, customers who cancel without anyone having called them before expiry. Purchase contracts are the ones through which you buy: rents, software licences, telecoms operators, data centres, rentals, insurance, consultancy. The risk is in costs: tacit renewals of services you no longer use, increases you accept because you do not check them, penalties you do not claim when the supplier gets it wrong.

The tools on the market were almost always born for one of the two sides. The recurring billing modules of Italian ERPs are designed for sales contracts: they generate the periodic invoice and do it well, but they usually know nothing about notice periods and clauses. Contract lifecycle management products, born in the legal departments of large companies, are designed for drafting, approval and signature, and they handle purchase contracts well but do not talk to billing. Before you look at any demo, write a single line: what do I want to stop happening. If the answer is "I want to stop paying renewals I did not want", you need one side; if it is "I want to stop giving away the adjustments", you need the other; if it is both, as it almost always is, the questions you ask suppliers change.

Contract management software, document archive and deadline calendar: three different things

A third misunderstanding concerns the boundary with the document archive. A document management system is for finding the right document, in the right version, with the right permissions, and keeping it in a compliant way. I wrote about it in document management software, and it is a useful prerequisite but not a sufficient one: a well archived contract can renew itself exactly like a lost one. The generic deadline calendar, the one with the reminder in your diary, is the other extreme: it remembers a date, but the date was typed by hand by someone who read the contract once, and it does not know that the 2023 addendum changed the notice period from ninety to one hundred and eighty days. Contract management software sits in between: it reads the document once, properly, and from then on it calculates.

The real cost of contracts kept in folders and spreadsheets

I will take the reference company, the one with the data centre rack, and keep it for the whole article so the numbers stay comparable. Eight hundred and seventy active contracts with customers: systems support, cloud phone systems, connectivity, managed backup, resold subscription licences. They are worth seven million two hundred thousand euros a year in recurring revenue, out of a total turnover of about nine million. One hundred and sixty purchase contracts: telecoms operators, licence distributors, two data centres, the rent on two offices, car rental, insurance, some ongoing consultancy. They are worth two million nine hundred thousand euros a year. In total one thousand and thirty contracts and more than ten million a year in value, managed with a spreadsheet for recurring billing, a shared folder with the signed PDFs and the memory of three people.

With the head of administration and the sales manager we measured five costs, one by one, over the last twelve months. I will go through them in order of weight, with the way we measured them, because the value of the exercise lies in the method more than in the total.

Price adjustments never applied

Five hundred and forty sales contracts out of eight hundred and seventy, sixty two per cent, had a clause tying the fee to the consumer price index. In recent years the adjustment had been applied regularly on only one hundred and ninety: those of the largest customers, where someone remembered because the amount was obvious. The other three hundred and fifty, worth about two million nine hundred thousand euros a year, were stuck at the signed price. After 2022 and 2023, when the index rose by more than thirteen per cent, that is not a detail.

Not everything you failed to ask for can be recovered: many clauses say the adjustment applies on request, and a request not made is not retroactive. But every year you do not apply it, the base on which you calculate the next one stays lower, and the loss carries forward. At the reference company, counting only the current year and only the adjustments the contract allowed them to request, this cost was worth fifty eight thousand euros. And it is the one you recover first, because a well written letter is enough.

Tacit renewals nobody wanted

For the one hundred and sixty purchase contracts we did something simple: for each one, we asked "if you had to sign it again today, would you sign it like this?". The data centre rack was the most striking case, thirteen thousand eight hundred euros a year, but not the only one. There were twenty three data lines in the company's name, installed at customers who had stopped the service, that nobody had ever closed with the operator. There were the licences of thirty one people who had left, renewed with the annual subscription. There was an insurance policy covering a risk already covered by another one, taken out by two different people a year apart.

Put together, spend on renewals that would not have been signed again was worth forty seven thousand euros a year. None of these items was anyone's mistake: each one was a contract that renewed itself because the date on which you could decide had passed without anyone seeing it.

Service delivered outside the contract and never invoiced

This is the cost that hurts most, because the work was done. A support contract covers twenty workstations, and in the meantime the customer has thirty four. Another covers a pool of forty hours a year, and in October the hours ran out two months ago. A third covers remote support, and the technician goes on site because the customer is pleasant and always asks politely. The technician does not know what the contract covers, because the contract sits in an administration folder and the technician works inside the ticketing system.

On a sample of three months of tickets we found that eleven per cent of hours were outside the scope of the contracts, and that only a quarter of those hours had been invoiced as extras. Over the year's value, sixty four thousand euros of service given away. It is the same problem I described from the job side in field service management software: there the question is how much each job costs, here it is whether that job had already been paid for or not.

Customers lost at expiry without a negotiation

In the last year the company had received forty one cancellations. For twenty five of them, sixty per cent, nobody had spoken to the customer in the previous six months: the cancellation was the first sign that something was wrong. Not all of them could have been avoided, because some customers close down or are acquired. But the sales manager, rereading them one by one, pointed to at least eight where a phone call four months before the notice window would have led to a renegotiation instead of a goodbye. Eight contracts, on the margin they produced, were worth thirty eight thousand euros a year.

The office looking for the contract

The last cost is the most widespread and the least visible: time. Recurring billing done by hand every month on one thousand and thirty spreadsheet rows, with two per cent of recurring invoices corrected by a credit note. Searches for the signed version of a contract, with the addendum that may or may not exist. Requests from sales people who want to know a customer's terms before calling them. Put together, it was about eighty per cent of one person across administration and sales, thirty four thousand euros a year.

The measured total is two hundred and forty one thousand euros a year. Against an operating profit of around six hundred and forty thousand euros, that is more than a third. And the thing to notice is not the figure, it is the structure: four costs out of five depend on the same missing piece of data, namely the next date on which something could still be decided about that contract. That is why the number that decides is the one in the next section, and not the number of contracts you have.

The share of value with no next useful date: the number that decides

The definition is simple. Take all your contracts, sales and purchase, with their annual value. For each one, ask whether there is, in a system and not in a PDF or in someone's head, the next date on which you can still change something: the last useful day to give notice, the date of the next adjustment, the expiry after which it does not renew. The share of value with no next useful date is the sum of the values of the contracts for which the answer is no, divided by the total value.

You weight by value and not by number for a practical reason: a contract worth three hundred euros a year that renews by mistake changes nothing, one worth a hundred thousand does. At the reference company the share was twenty seven per cent: two million seven hundred thousand euros a year of contracts for which nobody, without opening the document, could say when they could still be changed.

I use four thresholds. Below five per cent the contracts are already under control: someone knows what expires and when, notices go out on time, and new contract management software will give you convenience and continuity, not much margin. Between five and twenty the problem is the process: the dates exist but get lost when the contract changes with an addendum or when the person who followed it changes role, and a few written rules are worth as much as software. Above twenty the contracts have no memory: the calendar makes the decisions for you, and every month that passes it makes a few more. And then there is the most common case, never measured, which usually sits in the third band.

How to measure it in three days without a system

The first step is the one almost everyone gets wrong: you do not take the list of contracts from the archive, you take it from the money. The archive gives you the contracts someone saved; the money gives you the ones that really exist. For sales contracts you extract from the ERP every customer who received at least one periodic invoice in the last twelve months; for purchase contracts, every supplier paid something on a regular basis. At the reference company, comparing the two lists brought to light nineteen purchase contracts nobody knew they had, paid by direct debit.

Then you sort by value and start from the top. The first two hundred contracts by value usually cover eighty per cent of the total, and for each one you write down the expiry of the current period, the notice period, the renewal length and whether there is an adjustment clause, marking each item as certain, probable or unknown. For two people it is three days of work. If the contracts are already in a table, even just the billing spreadsheet imported into a database, the calculation is a query.

-- Share of value with no next useful date, by side and by category.
-- "Useful date" = last day to give notice, or next adjustment,
-- or final expiry: it is enough for at least one to be known and in the future.
WITH Stato AS (
    SELECT
        c.Lato,                      -- 'Attivo' (sales) or 'Passivo' (purchase)
        c.Categoria,
        c.ValoreAnnuo,
        CASE
            WHEN c.UltimoGiornoDisdetta >= CAST(GETDATE() AS date)
              OR c.ProssimoAdeguamento  >= CAST(GETDATE() AS date)
              OR (c.RinnovoTacitoMesi = 0 AND c.Scadenza >= CAST(GETDATE() AS date))
            THEN 0 ELSE 1
        END AS SenzaDataUtile
    FROM dbo.Contratti AS c
    WHERE c.Stato = 'InVigore'
)
SELECT
    Lato,
    Categoria,
    COUNT(*)                                            AS Contratti,
    SUM(ValoreAnnuo)                                    AS Valore,
    SUM(ValoreAnnuo * SenzaDataUtile)                   AS ValoreSenzaData,
    CAST(100.0 * SUM(ValoreAnnuo * SenzaDataUtile)
         / NULLIF(SUM(ValoreAnnuo), 0) AS decimal(5,1)) AS QuotaSenzaData
FROM Stato
GROUP BY ROLLUP (Lato, Categoria)
ORDER BY ValoreSenzaData DESC;

Look at the result by category before the total. The share is almost always concentrated in two or three families of contracts: at the reference company they were the purchase contracts with telecoms operators and the sales contracts of mid sized customers, those between three thousand and fifteen thousand euros a year, big enough to matter and too small for anyone to follow them personally. That is the scope of the first release, and it is no accident that it is also where three of the five costs were.

The heart of contract management software is the clause, not the PDF

Almost every project I have seen fail started from the document: you upload the PDF, attach ten descriptive fields to it, and build a nice search. Six months later the system holds every contract and has not prevented a single wrong renewal, because someone filled in the fields once and nobody updated them when the addendum arrived. The document is the proof of what you signed. What you decide on is something else: the clauses that have a consequence over time, written as data and not as text.

The model I use rests on five tables. The contract, with the counterparty, the side, the category, the internal owner and the status. The versions: the original contract and every addendum, each with the date from which it applies and the linked signed document, because an addendum does not add to the contract but replaces parts of it. The structured clauses: term, tacit renewal, notice period and form of notice, adjustment rule with the index and the percentage, service scope, service levels and penalties, each linked to the version it comes from and to the page of the document where it is written. The deadlines, which are not typed by hand but calculated from the clauses. And the billing obligations, that is what must be invoiced, when and at what price, which is the bridge to the ERP.

The trap is time, exactly as with vehicle assignments in a fleet. A clause is not a column next to the contract: it is a history. The notice period was ninety days until the 2023 addendum and one hundred and eighty since then; the scope was twenty workstations until January and thirty from February. A system that only keeps the current value tells you the right thing today and cannot explain why last year's invoice was different, and above all it cannot recalculate when you discover that the addendum was never signed by the customer.

The last notice date is calculated, not typed

The most useful rule in the whole project is this: nobody types the last notice date by hand. You enter the start date, the term, the tacit renewal length and the notice period, and the system calculates the date, every day. It sounds like a refinement, but it is the difference between a system that stays true and one that ages: when the contract renews, the next date comes out on its own; when an addendum changes the notice period, the date changes with it. The calculation is short, and this is the core I use.

// The data centre rack: signed on 1 March 2020, 36 months, 36 month renewal, 180 days notice.
// On 22 September 2026 the useful window is the one expiring on 28 February 2029,
// with notice to arrive by 1 September 2028. The 2025 one has passed.
var armadio = new Contratto("CD-2020-014", new DateOnly(2020, 3, 1), 36, 36, 180, 13_800m);
var finestra = Scadenziario.ProssimaFinestra(armadio, new DateOnly(2026, 9, 22));

public record Contratto(
    string Codice,
    DateOnly Inizio,
    int DurataMesi,
    int RinnovoTacitoMesi,   // 0 if the contract simply ends at expiry
    int PreavvisoGiorni,
    decimal ValoreAnnuo);

public record Finestra(DateOnly Scadenza, DateOnly UltimoGiornoDisdetta, bool GiaScaduto);

public static class Scadenziario
{
    // Returns the expiry of the period in which you can still decide
    // and the last useful day for the notice to arrive.
    public static Finestra ProssimaFinestra(Contratto c, DateOnly oggi)
    {
        var mesi = c.DurataMesi;
        var scadenza = c.Inizio.AddMonths(mesi).AddDays(-1);

        // If the notice window has already closed, the contract has renewed itself:
        // move to the next period, always counting from the start date
        // so as not to accumulate the drift from months of different lengths.
        while (c.RinnovoTacitoMesi > 0 && scadenza.AddDays(-c.PreavvisoGiorni) < oggi)
        {
            mesi += c.RinnovoTacitoMesi;
            scadenza = c.Inizio.AddMonths(mesi).AddDays(-1);
        }

        var ultimoGiorno = scadenza.AddDays(-c.PreavvisoGiorni);
        return new Finestra(scadenza, ultimoGiorno, scadenza < oggi);
    }
}

Two details that look small in the code and matter in reality. The first: the notice period counts from the date the notice arrives, not the date it is sent, so the internal alert must go out with a margin, and I use sixty days before the last useful day plus the time the required form needs. The second: many contracts do not start from signature but "from service activation", a date that is not in the document. It must be taken from the activation report or the first invoice, and the system must know it is a reconstructed date, because if you dispute it in a negotiation you need to know where it comes from.

The service scope must reach the people doing the work

The third cost, service delivered outside the contract, is not solved in administration. It is solved by bringing the scope to where the work happens: when the technician opens a ticket, they must see that the customer is entitled to twenty workstations and is asking about the twenty first, that the hours ran out in September, that on site visits are not included. Not to refuse the work, which almost always needs doing, but to record it as an extra at the moment it happens and not three months later, when nobody remembers anything. At the reference company a panel on the ticket screen, fed by the structured clauses, was enough to take invoiced extra hours from a quarter to two thirds in one quarter.

Tacit renewal, notice and adjustment: the three dates that make money

All the economic value of contract management software passes through three dates: the one by which you can give notice, the one on which you can adjust the price, and the one by which it pays to talk to the other party. Each has its rules, and some are legal rules worth knowing, because they change the way the system should be built. What follows is the framework I use with clients to set up the software, not legal advice: before you change your contract templates, have them reviewed by your lawyer.

Tacit renewal and the second signature

Between businesses tacit renewal is lawful and is the norm in service contracts. There is, however, a detail many companies overlook in their own sales contracts. If the contract is based on your general terms, that is on a form prepared by you and signed by the customer, the second paragraph of Article 1341 of the Italian Civil Code says that certain clauses have no effect unless they are specifically approved in writing, and among them is precisely the tacit extension or renewal of the contract. That is the reason for the second signature at the bottom of Italian forms, the one with the list of the articles referred to.

For the software this becomes a field almost nobody provides: was the renewal clause specifically approved, yes or no. At the reference company, checking the oldest sales contracts, we found about sixty signed on a 2016 form without the second signature. That does not mean those contracts are void, and the case by case assessment is for the lawyer. It means that with those customers the automatic renewal is a weak position, and it is better to reach expiry with an explicit renewal, perhaps with the adjustment built in, rather than relying on silence.

Notice: the deadline, the form, the proof

Notice has three elements, and the system must hold all of them. The deadline, that is the notice period, which is calculated on receipt. The form, which the contract usually prescribes: recorded delivery with return receipt, certified email, sometimes a specific address of the supplier's legal department. And the proof, that is the delivery receipt, which must be linked to the contract and kept. A notice sent by ordinary post to the supplier's sales person, even within the deadline, is a notice the supplier can dispute.

For purchase contracts the rule I recommend is even simpler: when in doubt, give notice. A notice sent in time does not force you to leave the supplier, it gives you back the negotiation. A supplier who knows your contract is expiring and has been cancelled offers you terms they would never have offered once the contract had renewed. At the reference company, in the first year with the deadline calendar, precautionary notices on the telecoms contracts led to renegotiating eleven contracts with an average reduction of fourteen per cent, without changing a single supplier.

Adjustment: automatic or on request, and with which index

The most common adjustment clause ties the price to the consumer price index for blue and white collar households, the FOI index published by Istat, the Italian national statistics institute. What changes from one contract to another, and what the system must hold as data, is everything else: what percentage of the change applies, with which reference month, whether the adjustment kicks in by itself or must be requested in writing, and whether there is a cap. In commercial leases, for example, Article 32 of Italian Law 392 of 1978 allows the rent to be updated every year by no more than seventy five per cent of the change in the index, and the update must be requested by the landlord.

The distinction between automatic and on request is the one worth money. An automatic adjustment not applied can almost always be recovered, because the right existed anyway. One on request that was not requested is usually lost for that period. That is why the system must generate the request, not just remind you of it: the letter to the customer with the calculation, the starting and ending index and the new fee, ready to sign and send in the required form. And it must generate the fee change in the ERP that invoices, otherwise you have sent a letter and keep invoicing the old price.

In ongoing service contracts there is also the price revision provided for by Article 1664 of the Italian Civil Code, when for unforeseeable circumstances the cost of materials or labour changes by more than a tenth of the total agreed price. It is a different tool from index adjustment, many contracts exclude or regulate it, and again it is something for the lawyer to assess. For the software the same rule applies: if the contract has a clause that changes the price, it must be in the system as data, with its condition and its form.

Renegotiation: the date that is not written anywhere

The fourth date is not in the contract and that is why it is the most valuable: the moment when it pays to talk to the customer before the notice window opens. I set it six months before the last useful day to give notice, and I assign it to the customer's account manager, not to administration. It is the date that would have saved the eight contracts in the fourth cost. Contract management software that calculates the first three and forgets this one protects you on costs and leaves you exposed on revenue.

Loading a thousand contracts: where artificial intelligence helps and where it gets it wrong

The hidden cost of every contract management project is not the software, it is the loading. Someone has to read every contract with its addenda and pull out about fifteen items of data: parties, dates, term, renewal, notice period, form of notice, adjustment, scope, service levels, penalties. Done by hand, by someone who knows contracts, a contract with a couple of addenda takes between twenty and twenty five minutes. For one thousand and thirty contracts that is about four hundred hours, two and a half months of one person, and it is why so many projects stop at the first hundred contracts and never restart.

This is where artificial intelligence really helps, and it is one of the cases where I use it with the most conviction. A language model reads a twelve page contract in a few seconds and proposes the fifteen fields, each with the sentence and page it took it from. A person checks, compares with the text, corrects where needed. At the reference company the time per contract fell to six to eight minutes, and the full load to about one hundred and twenty hours. The difference is not only cost: it is the difference between a project that finishes and one that stays half done.

Where the model gets it wrong, and why that is dangerous

On a sample of two hundred contracts we measured how often the model got it right on the first pass. On contracts made of a single document, ninety seven per cent of the dates were correct. On contracts with addenda, the share fell to sixty four per cent. The reason is always the same: the model reads the original contract well and does not understand that the 2023 addendum replaced its article 7. It is precisely on the clauses that matter most, notice period and price, that the error is most likely, because those are the ones the parties renegotiate.

There are three other difficult cases. Scanned documents with changes written in pen and initialled in the margin, which the model sometimes reads and sometimes does not. External references, such as "the general terms version 2019 apply", when the general terms are not attached. And relative dates, such as "from the date of service activation", which the model tends to replace with the signature date because it is the only one it finds. In all three cases the error is silent: the field is filled in, it looks right, and it is wrong.

The rule I draw from this is clear: the model proposes, the person confirms, and every field keeps the reference to the page and sentence it comes from. A field without a reference does not enter the system. Contracts with addenda are loaded as separate versions, in order, and the first thing checked is what the addendum says it replaces. And relative dates are marked as reconstructed, with the source they were taken from. With these three rules artificial intelligence cuts the time by two thirds without introducing errors that then cost more than the time saved.

Where you send your contracts

One last warning, worth more than all the percentages. Contracts contain personal data, confidential commercial terms and sometimes your customers' trade secrets. Pasting them into a free chat service is the wrong thing to do, even if it works. Extraction should be done with a model used under a contract that excludes the use of your data for training and says where it is processed, or inside your company's own cloud environment. If assisted extraction is a feature of the product, ask the contract management software vendor in writing: where the documents go, who sees them, how long they stay.

How much contract management software costs: ERP module, dedicated product or custom

There are three routes, plus a fourth that is usually the best. I will give you the price ranges I see on the Italian market today, for a company the size of the reference one.

The first is the contracts module of the ERP you already have. Many Italian ERPs have a module for periodic contracts, sometimes included, more often between two and six thousand euros a year. It does one thing well: it generates recurring invoices from sales contracts, with billing periods, accruals and sometimes index adjustments. It usually knows nothing about purchase contracts, does not handle addenda as versions, does not calculate notice windows and does not bring the scope into the ticketing system. If your problem is recurring billing done by hand, it is the first thing to try, and you have often already paid for it.

The second is a dedicated product for contract management, on subscription. For a company like the reference one the fee is between six thousand and twenty thousand euros a year, depending on users and number of contracts, plus a setup of between ten and thirty thousand euros that is almost all loading, and that assisted extraction can halve. Good products handle deadlines, alerts, versions, archive and electronic signature well. The typical limit is the bridge to what you already have: billing stays in the ERP, tickets stay in their system, and the connection is often a periodic export instead of shared data.

The third is a custom system. It starts from forty five thousand euros for the contract register with versions and addenda, structured clauses, the calculated deadline calendar with alerts, adjustments with the generated letter and the connection to ERP billing. It goes up to one hundred and twenty thousand with the portal where customers see their own contracts and usage, integrated assisted extraction, scope in the ticketing system, electronic signature and renewals with a tracked negotiation. On top of that comes fifteen or twenty per cent a year for maintenance.

The threshold: about one thousand four hundred contracts

The product costs in proportion to how much you use it, the custom system hardly at all. On the cumulative five year cost, with a setup of twenty thousand euros for the product and a build cost of sixty thousand plus maintenance for the custom system, the two lines cross at around one thousand four hundred contracts, that is when the product fee exceeds twenty three thousand euros a year. With the reference company's one thousand and thirty contracts the product costs about one hundred and seventeen thousand euros over five years, against one hundred and thirty two thousand for the custom system. Below the threshold the product almost always wins; above it, every extra contract costs the product a slice of fee and the custom system almost nothing.

But the number of contracts is not the only variable, and this is the part comparison tables do not tell you. If the value of your contracts runs through rules no product knows, such as usage based billing with thresholds and tiers, a scope that changes every month based on the customer's active users, or framework agreements with dozens of call off orders, the product forces you to manage outside it, in a spreadsheet, exactly the part that is worth money. And at that point the threshold drops considerably, because you are paying a fee for the easy part and still doing the hard part by hand.

The fourth route, the one I almost always recommend

The route I recommend in most cases is mixed: the ERP module for billing, a custom piece for clauses and dates. The ERP you have already does recurring billing well, and redoing it costs money and adds risk. What is missing is the clause register with versions, the calculated deadline calendar, adjustments with the letter and the fee change, and the scope brought into tickets. Built custom, on top of the ERP and connected through its interfaces, it costs between fifteen and forty thousand euros, and it does not oblige you to maintain the part the market already does well. At the reference company the custom piece cost thirty two thousand euros and paid for itself in the first year from the adjustments and precautionary notices alone. This hybrid route almost always works better than either pure one, and if you want to discuss it for your company, get in touch.

The five questions to ask before you sign

Whichever route you choose, there are five questions that separate good contract management software from an archive with a calendar. The first: does it handle addenda as versions that replace clauses, keeping the history, or as attachments? The second: does it calculate the last notice date from the clauses, or does a person type it? The third: does it calculate the adjustment from the index, generate the request in the required form and update the fee in the system that invoices? The fourth: does it export everything, clauses included, in a format you can read without it? The fifth, worth more than the other four: will the vendor agree to load your twenty most complicated contracts, the ones with three addenda and relative dates, and show you the calculated notice windows before you sign? If it reconstructs eighteen out of twenty you have the right product; if it reconstructs twelve you have an archive.

Where to start: the first release in ninety days

The first release does not have to be complete, it has to be useful to someone within three months. This is the order I use, and the first steps cost little and are worth a lot because they happen before the software.

Weeks one and two: the list from the money, and the measurement. Extract the contracts from issued invoices and recurring payments, compare them with what is in the archive, sort by value and calculate the share of value with no next useful date on the first two hundred. At the end of the two weeks you should have a number, the family of contracts that weighs most and the list of contracts nobody knew they had. Almost always, already at this stage, a notice turns up that needs sending straight away.

Weeks three to six: the first two hundred contracts, done properly. Loading of the first two hundred contracts by value, with assisted extraction and human review, versions and addenda in order, every field with its reference. At the same time you write down a single rule, worth more than everything else: no contract, no addendum and no notice enters or leaves the company without going through the register.

Weeks seven to ten: the deadline calendar and the adjustments. Calculated notice windows, with an alert to the owner sixty days before the last useful day and the renegotiation date six months before for sales contracts. Adjustments calculated from the index, with the letter ready and the list of customers to send it to. This is the moment the project starts giving money back, and it is better that it happens early, because that is what keeps attention alive for the rest.

Weeks eleven to thirteen: the bridge to billing and tickets. Fee changes that flow automatically into the ERP that invoices, and the contract scope visible on the ticket screen. The rest of the contracts, those below the first two hundred, are loaded afterwards, at a steady pace, with the same procedure. The customer portal, electronic signature and tracked negotiations come when the register is reliable, not before.

One last piece of advice on what not to do first. The dashboard with charts of expiring contracts is the part you see in every demo, and it is the one you need least at the start. A weekly list of ten lines, sent to the right people with the date, the contract and the action to take, is worth more than any chart, because someone reads it and does something.

If the number says it is not your problem

It can happen, and it is worth saying because almost nobody does. If your share of value with no next useful date is below five per cent, if notices go out on time and adjustments are applied every year, new contract management software will not give you much margin back: it will give you convenience, continuity when the person who looks after contracts changes role, and an archive that is easier to search. Those things have value, and in a small or mid sized company continuity is worth more than it seems, because there is almost always a single person who knows how the contracts really stand. But they are worth the price of a subscription, not of a project.

In that case the bottleneck is almost always elsewhere, and in companies that live on contracts it is one of these three. The margin on individual contracts: you know perfectly well when they expire, but you do not know which ones make you money and which do not, because technicians' hours are not charged back to customers, and then the topic is the one described in management control software. The cost of each job: the contracts are in order but every job costs more than planned because of repeat visits, and I wrote about it in field service management software. Or supplier spend outside the agreements: purchase contracts are under control, but part of the buying happens with no contract behind it, and then the topic is supplier management software.

And there is one case where software is not the answer even when the numbers are bad: when contracts are a formality nobody respects. If large customers always get everything they ask for regardless of what they signed, if adjustments are not applied by commercial choice and not by oversight, no system will change that choice: it will only tell you precisely how much it costs. Which, incidentally, is already a very good reason to measure, because many concessions made to keep a customer are worth more than they seem, and until the number exists the discussion cannot even begin.

If you have read this far you probably have two or three contracts in mind for which you could not say, without opening the PDF, when you could still change them. Calculate the share of value with no next useful date on your first two hundred contracts before you look at any demo: it is three days of work, it costs nothing, and it tells you whether you are buying margin or just order. From there on the decisions are much simpler, and you make them yourself instead of leaving them to the calendar.