Short answer
Automating contract management means turning a folder of documents into a calendar of dates and obligations. A model extracts the parties, the term, the renewal mechanism, the notice period and the commitments; deterministic checks confirm each extracted date is real and consistent; and the alert fires at the renewal date minus the notice period minus the time your company actually needs to decide. Everything after the alert stays human — no automated system should ever send a termination notice.
The problem is dates, not documents
Ask a company of 10 to 100 people where their contracts are and you will usually get a decent answer: a shared drive, a folder per supplier, sometimes a proper repository. Ask them which agreements renew in the next ninety days and what notice each one requires, and the room goes quiet.
That gap is the whole subject. Storage was solved a long time ago. What is not solved is that the obligations inside those documents — dates, thresholds, commitments, indexation clauses — are written in prose, buried in section 11.3, and therefore invisible to every system in the company. They are only visible to a person who reads the contract, and nobody reads a contract twice.
So the work is not "find the document faster". Retrieval is a different job with a different architecture, covered in making an assistant answer from your own files. The work here is extraction into a structure, and then a calendar built on top of that structure. One is a search problem. The other is a monitoring problem, and monitoring is what actually costs money when it is missing.
A useful way to know which problem you have: if the pain shows up when someone is looking for something, it is retrieval. If the pain shows up when nobody was looking at all, it is monitoring — and no amount of better search will fix it.
What to pull out of each contract
Resist the temptation to extract everything. A large schema is slower to verify, and a field nobody checks is a field that will be wrong without anyone noticing. Six items carry nearly all the value.
- The parties and the signature date. Dull, and the anchor for everything else — several later checks depend on knowing when the term actually started.
- The term and its end date. Fixed period, indefinite, or tied to a milestone. Each behaves differently and the difference decides whether a renewal date exists at all.
- The renewal mechanism. Whether it ends, rolls over automatically, or requires a positive act to continue. This single field separates the contracts that can hurt you from the ones that cannot.
- The notice period. The number and the unit, exactly as written, plus the clause it came from. Everything in the next section depends on this being right.
- Price and indexation. The amount, the currency, and whether an adjustment is scheduled or triggered. Money leaks through indexation clauses nobody applied, not only through renewals nobody stopped.
- The obligations you owe. Service levels, reporting commitments, volume minimums. These are the ones that surface at the worst possible moment, in a dispute, when the other side has read the document more recently than you have.
Store the clause reference alongside every extracted value. It costs nothing at extraction time and it is the difference between a value someone can verify in ten seconds and a value they have to re-read the whole contract to trust.
The alert has to be calculated backwards
This is the part that gets built wrong most often, and the failure is silent until the year you lose. Teams set a reminder thirty days before the renewal date, feel organized, and discover too late that thirty days was never the relevant number.
The date that matters is not the renewal. It is the last day you can still give valid notice, which is the renewal date minus the notice period written in that specific contract — which might be one month, might be ninety days, and might be counted from a date that is not the one you assumed. Then subtract the time your own organization needs to make the decision: pulling the usage numbers, deciding whether the service is still worth it, getting a signature from someone who is on holiday.
In the companies we work with, that internal lead time is consistently the underestimated term — a pattern from our own engagements rather than a published benchmark. A supplier decision that feels like a five-minute call in theory often takes something like three weeks in practice, because it needs someone to look at the numbers first. Set your alert at renewal minus notice minus that internal time, and set a second one at renewal minus notice, as a last call.
Two alerts, not one. The first is "start deciding". The second is "decide today or you have decided by default". A single reminder always ends up being one or the other, and it is usually the wrong one.
The legal specifics — whether an automatic renewal is even enforceable, what notice a supplier owes you, what form a termination must take — vary by jurisdiction and by contract type, and this article deliberately makes no claim about them. Get that answered locally, once, and encode the answer in the calendar rather than in someone's memory.
Checking an extraction you did not do yourself
Reading a clause and returning a value is a judgment step, with everything that implies: it will be right most of the time and confidently wrong occasionally, and the wrong answers look exactly like the right ones. The general principle is in the line between rules and judgment. What follows is what it means specifically for contracts.
- Every date must parse and be plausible. A renewal date before the signature date, or eleven years out, is an extraction failure, not an unusual contract. Reject it mechanically rather than storing it.
- Term, start and end must agree. If the contract says three years and the extracted dates span fourteen months, something was read from the wrong clause. This one check catches a surprising share of errors at zero cost.
- The notice period must exist in the source text. Search the document for the number that was returned. If it is not there as written, do not accept it — this is the field with the highest cost of being wrong and it deserves the strictest check.
- A human confirms the first pass, contract by contract. Once, at import, with the clause reference next to each value so the check takes seconds. After that the calendar runs on its own.
That last point is the one people try to skip, and it is the one that makes the system trustworthy. Extraction across a whole back catalog without a single human pass produces a calendar that is roughly right — and a calendar that is roughly right about dates is not usable for the decisions it exists to support.
The corpus problem nobody budgets for
Contracts are the worst-behaved documents in most companies. Some are clean digital originals. Some are scans of signed pages, sometimes photographed at an angle, sometimes faxed at some point in their history. Some exist only as an amendment referring to a master agreement nobody has located.
This matters more than the choice of tool, because poor text extraction does not fail loudly — it yields values that look entirely reasonable and are simply not what the document says. Three habits keep it under control.
- Start with the contracts that can hurt you. Active, renewing, above a spend threshold you choose. A complete historical archive is a project; the ten agreements that renew this quarter are a week.
- Route poor-quality documents to a person instead of pushing them through. When the extracted text is sparse or garbled, that is a signal, and the correct response is manual entry — not a retry with a bigger model.
- Track amendments as first-class documents. An amendment that changes a notice period silently invalidates the value extracted from the original. If your structure has no place for "superseded by", your calendar will be wrong about exactly the contracts that were renegotiated — the important ones.
Where the automation must stop
Everything above produces information. The moment the system starts to act, the risk profile changes completely, and there is a clean line to draw.
Automated: extracting, verifying, storing, alerting, preparing a draft notice, assembling the numbers someone needs to decide. All of it reversible, all of it visible before anything leaves the company.
Never automated: sending a termination, agreeing to a renewal, signing anything. Not because a model could not draft the letter — it can, and it should — but because these acts are irreversible and externally binding. A wrong classification in an inbox costs a minute; a termination sent to the wrong supplier costs a relationship, and possibly a payment.
That is the same reversibility test we apply to every automated step, and contracts are the clearest case for it. If you want the sequencing of which process to build before this one, that logic is in deciding what to automate first, and the practical question of building it without a developer is in automation without developers.
Frequently asked questions
What is the most expensive thing that goes wrong with contracts?
Not losing a document — missing a date. A contract you cannot find is an afternoon of annoyance; a renewal that rolled over because the notice window closed three weeks ago is a year of cost you already agreed to. The same applies in the other direction, to price indexation clauses you were entitled to apply and did not, and to obligations you owe a client that nobody tracked. Search solves the first problem. Only a calendar built from the contracts solves the second.
Can a model be trusted to read a contract?
To find and extract, yes, with checks. To decide, no. Extraction is the kind of task models are genuinely good at: locating a term, a date or a party in a long document and returning it in a structured form. What must stay deterministic is everything downstream — verifying the extracted date actually parses and falls inside the contract term, comparing it against the signed document before anyone acts, and never letting an automated step send a termination notice. Propose, verify, then have a human act.
What do we do about contracts that only exist as scans?
Treat scan quality as the real project, not an afterthought. Text-layer PDFs extract cleanly; photographed or faxed pages produce plausible-looking values that are quietly wrong, which is worse than failing. The workable approach is to process the recent and high-value contracts first, flag any document whose text extraction looks poor for manual entry rather than pushing it through, and accept that a small tail will always be typed by a person. A corpus of 200 contracts where 20 are checked by hand beats 200 where nobody knows which 20 are wrong.
How far ahead should a renewal alert fire?
Work backwards, not forwards. The date that matters is the last day you can give notice, which is the renewal date minus the notice period stated in the contract. Then subtract the time your organization actually needs to make the decision — gather the usage numbers, get an opinion, obtain a signature. In the companies we work with, that internal lead time is routinely longer than anyone expects — our own observation rather than a published benchmark — which is why an alert set at a round thirty days so often arrives after the practical deadline has passed.
If you want the calendar built from your own contracts rather than described in the abstract, that is a two-week piece of work for most companies your size. Book a call and bring the agreement you are least sure renews when you think it does.
