Why a process beats good intentions
Most growing companies already follow some kind of contract process. It lives in people's heads: sales knows to send order forms to the finance lead, the office manager knows where the NDAs are, and the founder remembers that the office lease renews in March. That works until one of those people is on holiday, changes role or leaves.
Writing the process down does three things. It makes each stage somebody's job, it defines the output that the next stage depends on, and it lets you check, for any contract, which stage failed when something goes wrong. The seven stages below are deliberately simple. If you want the wider context first, read our guide to contract lifecycle management.
Stage 1: Request and intake
Every contract starts with a need. The intake stage captures that need in a structured way so that the drafter is not chasing details by email.
- Owner: the person who needs the agreement.
- Output: a request with the counterparty, contract type, estimated value, start date and the internal owner.
- Checklist: counterparty legal name confirmed; contract type chosen from your list; value and currency entered; internal owner named; any deadline stated.
A short intake form is enough. The point is that the value and type are known at the start, because they decide who approves later.
Stage 2: Drafting
The draft either comes from your template or from the other party's paper. Your own template is faster and safer, because the standard terms are already approved.
- Owner: the requester for standard templates, legal counsel for anything else.
- Output: a first draft in the repository, linked to the request.
- Checklist: latest template version used; variables filled (names, dates, amounts, term); clauses from the clause library rather than retyped; third-party paper uploaded as the starting version.
In AgreementSoftware, a first draft is produced from a form that fills the template variables, and the clause library holds approved wording for the clauses people usually rewrite from memory.
Stage 3: Negotiation and redlining
This is the stage where versions multiply. The risk is not the negotiation itself; it is losing track of which version is current and signing something that differs from what was agreed.
- Owner: the requester, with legal counsel for non-standard changes.
- Output: an agreed version, with every earlier version kept.
- Checklist: each round saved as a new version, not overwritten; changes compared between versions before accepting; non-standard changes flagged for legal review; final version marked as agreed.
Comparing versions side by side is the fastest way to spot a change the other side made without mentioning it. Our contract redlining software page shows how redlines and version comparison work in the product.
Stage 4: Approval
Approval is where authority is checked. The question is simple: did the people who are allowed to commit the company to these terms actually agree to them?
- Owner: the approvers defined by your rules.
- Output: a recorded approval with names, dates and comments.
- Checklist: approval rule matched by contract type and value; each approver in the chain has approved; comments resolved; audit trail saved with the contract.
A typical rule set for a company without legal ops is short: contracts under a value threshold need the department head; above it, finance as well; any non-standard liability or indemnity wording, legal counsel. On the Plus plan and above, approval workflows route drafts automatically according to rules like these, and every decision lands in the audit trail.
Stage 5: Signature and filing
Signature is the stage everybody watches, which is why it rarely fails outright. What does fail is filing: the executed copy stays in an inbox or an e-signature account, and the repository holds only a draft.
- Owner: the requester.
- Output: a fully signed PDF in the repository, with its audit certificate.
- Checklist: signing order set (usually counterparty first, then your signatory, or the reverse by policy); reminders on; signed PDF and certificate filed against the contract record; status changed to active.
With electronic signature software built into the same system, the signed PDF and its audit certificate are filed back into the repository automatically, so there is no filing step for anyone to forget. In the United States, the ESIGN Act and UETA make electronic signatures legally valid for most business contracts; some document types, such as wills and certain court and family documents, are excluded. That is a factual summary, not legal advice.
Stage 6: Obligations and performance
Once a contract is active, it creates duties on both sides: payment terms, service levels, reports, insurance certificates, price reviews, minimum purchase commitments. This is the stage that most processes skip entirely.
- Owner: the internal owner of the contract.
- Output: a list of obligations with dates and a responsible person.
- Checklist: key terms extracted and verified (parties, effective date, term, auto-renewal, notice period, termination, payment terms, liability cap, governing law); obligations entered with due dates; reminders set; owner confirmed.
Extraction does most of the typing here. Each extracted field shows the source sentence it came from, so the owner verifies rather than retypes. See AI contract management software for how extraction handles the key terms.
Stage 7: Renewal, amendment or termination
Every contract ends somehow. It expires, renews automatically, gets renegotiated, is amended or is terminated. The notice deadline decides which of those options are still open to you.
- Owner: the internal owner, with finance for anything above the value threshold.
- Output: a recorded decision (renew, renegotiate, terminate) taken before the notice deadline.
- Checklist: notice deadline computed from the term and notice period; alerts received at 90, 60, 30 and 7 days; decision recorded; notice sent in the form the contract requires; amendments linked to the original.
A worked illustration: a contract with a term ending on December 31 and a 90 day notice period has a notice deadline on October 2. If the renewal is automatic and nobody acts by October 2, the choice is gone. Alerts at 90 days before that deadline give the owner a full quarter to decide. Our contract renewal management software page explains how the deadline is calculated.
The contract lifecycle management process checklist
Copy this list into your playbook. Each line is a yes or no question for any single contract.
- Is there a request with the counterparty, type, value and an internal owner?
- Was the draft built from the current template or uploaded as third-party paper?
- Is every negotiation round saved as a separate version?
- Did the approvers required by type and value approve, and is the trail stored?
- Is the fully signed PDF, with its certificate, in the repository?
- Are the key terms extracted and checked against the source sentence?
- Are obligations entered with dates and a responsible person?
- Is the notice deadline computed, and will the owner be alerted before it?
- Is the renewal decision recorded before the deadline?
Run the list against your ten largest contracts first. Wherever the answer is "no", you have found the stage your process needs to fix.
Adapting the process to your size
A company of 30 people can run all seven stages with one admin and the business owners. A company of 500 people usually adds folder-level permissions, a dedicated approver for procurement and a reporting view for finance. The stages stay the same; only the number of people at each stage changes. The CLM workflow article shows a concrete version for teams without legal ops.
Measuring whether the process works
You do not need a reporting team to know whether the process is healthy. Three numbers, checked once a quarter, tell you most of what you need: the share of active contracts with a named owner and confirmed dates, the average time from request to signature, and the number of renewals that happened without a recorded decision. The last number should be zero. If it is not, stage 7 is where to look first.