A contract approval workflow: legal review, a signing decision, and a way to send it back

SynaptaGrid8 min read

#approvals#legal

In short

A contract approval workflow is the path a contract takes from the first draft to a recorded decision: legal reviews the terms, a senior person decides whether the business wants to commit, and the contract ends approved for signature, sent back for changes or rejected. Most contract problems come from a missing middle option and from signing without a clear record. Legal cannot say approve if this clause changes, so it chooses between approving a contract it dislikes and rejecting one that is nearly fine, and nobody can tell afterwards who agreed to what. A good workflow gives legal three choices, keeps the legal question and the commercial question apart, and writes the status onto a record. We built a small version in our own test workspace in which an AI tool, written for this job and used as an action in a normal step, reads the contract text, rates the risk, names the clause that most needs legal attention and writes a short summary, and the workflow writes all three onto the contract record before legal reviews it. We ran it three times, once approved, once sent back by legal and once rejected by the executive, and checked the contract records afterwards.

What a contract approval workflow is

A contract commits the company to terms, to a price and often to a renewal. Before anyone signs, a company wants a lawyer to have read the terms and a person with authority to have agreed to the commitment. A workflow writes down who does each, in what order, and what the possible answers are.

The workflow does not negotiate or decide. Legal and the executive do. It makes sure both look, that a contract with a problem has a route back for changes, and that every contract ends in a status anyone can find.

The version we built

An AI tool, used as an action in a normal step, reads the contract and the workflow writes the risk rating, the flagged clause and a summary onto the record. Legal can then approve, reject or send the contract back. If legal approves, an executive decides whether to approve it for signature. Automatic steps create the contract record and set its status at each ending.

The steps to include, and who owns each

Record the contract
When a contract is submitted, a record is created with the other party, a status of submitted for review and a flag that it is not yet ready to sign. Every later step reads from and writes to that record.
Read the contract text
This is where an AI tool helps. It reads the contract text, rates the risk as low, medium or high, names the clause that most deserves attention and writes a short summary. The next step writes all three onto the contract record, so legal starts with a pointer to the clause. The tool does not approve or reject anything.
Legal review
Legal reads the terms, the liability and the renewal clauses. Legal knows the risk in the wording, which the business owner may not see.
A third answer
Besides approve and reject, legal can send the contract back for changes. That ends this round with a clear status, and a revised contract is submitted again. Without this option lawyers reject contracts that one change would fix.
Executive decision
A senior person decides whether the business wants to commit at this value and on these terms. This is a commercial question, separate from the legal one, so it is a separate step with a different owner.
Reject from either step
A contract can be rejected by legal or by the executive. Both lead to the same ending: the record is marked rejected.
Mark the result on the record
Each ending sets the status and the ready-to-sign flag: approved for signature, sent back for changes, or rejected. The workflow does this itself.
Hand off to signing
Collecting signatures usually happens in another system. Decide where an approved contract goes next and add that as its own step.

Where approvals and checks belong

Put each decision with the person who has the information. Legal has the wording and the risk, the executive has the budget and the strategy. Splitting them stops a lawyer from guessing at the commercial case and an executive from judging a clause they have not read.

Name each approver by role, such as the legal team and the executive who owns the budget, rather than by person. If you need an extra approval above a contract value, or for a particular type of contract, add it on your own policy; we did not build that.

The old way and the new way

The table compares contracts handled by email and shared folders with the same contracts run as a workflow.

First read of a contract
The old way: Legal reads it cold
The new way: An AI tool rates the risk and names the clause first
Where the contract is
The old way: In an inbox or a shared folder
The new way: At a named step, with an owner
Answers available
The old way: Sign or do not sign
The new way: Approve, reject or send back for changes
Who agreed to what
The old way: Reconstructed from email threads
The new way: A recorded decision at each step
Whether it can be signed
The old way: Ask legal
The new way: The record says ready to sign or it does not
Finding a contract later
The old way: Search folders and inboxes
The new way: Open the record and read its status
Judgement
The old way: Still legal’s and the executive’s
The new way: Still theirs: whether the terms are acceptable, whether to commit

How we decided

We built the version in the diagram in our own test workspace in SynaptaGrid Automation, with a small record type in SynaptaGrid Data for the contract, and ran it three times in November. The AI part is a custom tool we wrote for the job: a prompt that says how to review a contract, an input that takes the contract text, and an output with a risk rating from a fixed list, the clause to look at and a short summary. In the workflow it is an action in an ordinary step, set up like any action that calls another system, and the next step writes its result onto the record. In the first run legal approved and the executive approved for signature. The workflow created the contract record with the status Submitted for review and the ready flag off, then wrote the AI review onto it, then updated the same record to Ready to sign with the flag on, and the run finished with the approved result. In the second run legal sent the contract back for changes: the run skipped the executive, marked the record Sent back for changes and ended. In the third run legal approved and the executive rejected, so the record ended as Rejected.

We checked the three records in Data afterwards. The approved one showed Ready to sign with the flag on. The sent-back one showed Sent back for changes, and the rejected one showed Rejected, both with the flag off. All three carried the AI review: a medium rating, the clause on automatic renewal with a ninety day notice period and fee increases, and a summary of two sentences. The summaries differed only in wording. One said the contract allows uncapped fee increases of up to ten percent, which contradicts itself: the text caps the increase at ten percent. It is a small slip and shows why legal reads the summary against the contract and does not treat it as fact. The AI tool did not work first time. Our earlier attempts to call it failed until we named the model in full in the tool’s settings, and our first version did not use its output in a later step. Then the record write was refused, because the tool’s summary was allowed to be longer than the text field on the record holds. Next, one run failed at the AI call because the model wrote a summary over our new, shorter limit, so we asked for shorter text in the prompt. The version described here is the one whose three outcomes we checked.

One path was not run on its own. A rejection by legal leads to the same rejected step the executive’s rejection uses, and we ran that step through the executive’s rejection only. We chose a third answer for legal and a separate executive decision because those are the places contract approval usually goes wrong. The choice of steps is ours and a judgement; it is not a standard.

Six limits, so this guide does not claim more than the runs showed. The tool saw one short contract excerpt, so we did not test a long contract, an unusual clause or a contract with no risk, and we did not compare its rating with a lawyer’s. One test account held every human step, so the runs show the sequence and the branching, not hand-offs between different people. Legal’s review was a person’s decision: the workflow does not read the contract, compare it with a template or find risky clauses, and we did not connect it to a document store or an e-signature service, so nothing was signed and the ready flag is a stand-in. We did not build an extra approval above a contract value, a loop that brings a revised contract back to legal, or a link between a sent-back contract and its replacement. We did not test reminders when a step waits too long or notifications to the other party. And the template carries one test account as every approver and the actions tied to our test record type, so to reuse it you would change each step to a role and point the actions and the tool at your own, which we did not do.

Standards and accepted practice behind this

These are the practices the guide rests on. We align with them. This page does not claim a certification.

Human oversight of AI
Where AI helps with a decision, accepted practice is to keep a person accountable for it and to let them see the AI’s input and output. Here the tool rates and summarizes, and legal and the executive decide.
Source: EU AI Act (Regulation 2024/1689), Article 14: human oversight (opens in a new tab)
Segregation of duties
The person who reviews the legal risk and the person who commits the company should be different, so one person does not both judge the wording and decide to sign.
Source: NIST glossary: separation of duty (opens in a new tab)
Delegated authority
Companies usually limit who may sign contracts and up to what value. The executive step is where that limit is applied, and it should follow your own signing policy.
Documented approval
Auditors and counterparties may ask who approved a contract and when. A step that records the decision and a record that carries the status are that evidence.
Retention of records
Contracts are usually kept for a period set by law and by the contract itself. Check yours before you decide how long the records stay.
BPMN
The standard notation for drawing a process. The diagram above is a plain flowchart, and a BPMN diagram of the same steps would show the same decisions.
Source: OMG: BPMN 2.0 specification (opens in a new tab)

Where SynaptaGrid fits

SynaptaGrid Automation lets you write the steps as a workflow, assign each decision to a person, use an AI tool you wrote as an action in a step, pass its result to the next step, create and update records in SynaptaGrid Data as part of the run, and see where every contract stands. You can start from the version above, change the steps to match your own signing policy, and keep the result as a template.

Check the limits above before you rely on it: whether each step is assigned to a role rather than a person, whether approval depends on a contract value, whether approved contracts must reach an e-signature service, and who should be told when a contract waits.

Frequently asked questions

What steps should a contract approval workflow have?
Record the contract, a legal review with a way to send it back, an executive decision on signing, a way to reject from either step, and a status written on the record.
Why let legal send a contract back?
Because the answer is often approve if this changes. A send-back route ends the round cleanly and avoids a rejection for something one edit would fix.
Who should approve a contract for signature?
A person with authority to commit the company at that value, decided by role rather than by name and following your own signing policy.
Can AI review a contract?
It can read the contract text, rate the risk and point at the clause that most needs attention. In our test run it rated a short services agreement medium and named the renewal clause, with one small slip in the summary. It does not replace a lawyer, and legal and the executive still decide.
Can a workflow update the contract record for me?
Yes. In our test run the workflow created the contract record when it was submitted and set its status and ready flag at each ending. You need a record type for the contract and each action pointed at it.
Share

SynaptaGrid

Build your contract approval steps

Start with the steps above in a test workspace and run one contract through each outcome before you use it for real.