Verify every CO. Before you approve.
Change Order Review is the Trueleveler engine that reviews change orders against the contract, schedule, and procurement record. Flags scope already in base contract, markup above your agreed cap, schedule impacts already paid via T&M, and unit-price math errors — with dollar impact per finding.
Try it now
Change Order Review needs a free account (no card). Inside, it has a Load sample button, so you can see a finished result before you upload anything.
The patterns that quietly bleed margin.
Six categories cover the bulk of where CO reviews go wrong in the field. Every flag carries a severity tag, the dollar impact, and the source citation — the contract clause, schedule activity, or prior PO line that triggered it.
"Added work" was contractually included
Sub claims $42K to relocate three plumbing risers. The plumbing scope in the executed contract specifies "all risers per drawing P-203" — which includes the relocated positions. We cross-reference the CO description against the contract's own scope language, including any drawing references it cites.
Delay claim duplicates T&M billing
Sub bills 14 days of delay impact at $3,200/day for the same period they billed 92 hours of T&M crew time. Both can't be true. We pull T&M logs from the procurement record and surface the date overlap.
15% markup on a contract capped at 10%
Sub's CO carries a 15% O&P markup. The executed subcontract caps CO markup at 10%. We surface the contract clause, compute the corrected total, and flag the $4,260 delta on a $28,400 CO.
Quantity × rate doesn't match line total
180 LF × $43.50/LF = $7,830. The CO says $8,140. A $310 transcription error stacked across 14 lines becomes $4,340. We recompute every unit-price line and flag deltas above your rounding tolerance.
Hourly rates above the master agreement
Master agreement: journeyman electrician $86/hr loaded. This CO bills $94. Could be a year-end escalation (valid) or rate creep (not). Flagged with the master rate, the CO rate, and the rate-escalation clause to verify against.
RFI exists. Was it a scope change?
CO traces back to RFI-047 (slab edge condition at column C-7). RFI was answered as "clarification of existing scope" — not a design change. We flag the entitlement gap with the RFI response language for the PM to confirm.
PCO submitted. Cross-checked. Annotated.
One screen. Left side: the CO exactly as the sub submitted it. Right side: every finding the engine surfaced — severity-tagged, dollar-tagged, citation-linked back to the source.
A reviewer's brief, formatted for the next CO meeting. Findings ordered by dollar impact. Each finding deep-links to the source (contract clause, schedule activity, prior pay app). PM signs off, denies, or routes for negotiation — the audit trail captures the decision.
The cross-checks that single-purpose tools miss.
A CO review tool that only reads the CO will catch math errors. The real value is in the cross-checks — the contract clauses, the schedule activities, the prior procurement record. We pull from each, then surface what doesn't line up.
Markup caps · T&M rate ceilings
Pulls the executed subcontract's markup cap, escalation clause, and rate ceilings — checks every CO against those constraints automatically.
Delay-claim verification
When a CO claims schedule impact, we match it to the closest activity in your current project schedule and run the same deterministic CPM math Schedule Risk uses to check whether that activity sits on the critical path — a real schedule read, not model guesswork. (This checks your schedule as it stands today, not a historical snapshot from when the CO was submitted, and it doesn't yet classify the change as owner-directed vs. contractor-caused.)
"Already paid via T&M" check
Pulls pay-app and T&M logs for the affected sub and period. Surfaces overlaps between CO-claimed work and previously billed work — a common margin leak.
This is what we mean by project memory. Each engine on its own catches what it can read. The chain catches what no single document reveals.
The CO log your owner already wants to see.
Every reviewed CO lands in a single project register — statused, dated, dollar-impact tracked. Owner-side meetings get a clean export. Internal meetings get the full register including disputed-and-denied COs with reasoning.
Clean register, redacted internals
Status, CO number, vendor, brief description, current dollar value, days impact, approval state. Disputed amounts surfaced; specific sub-vendor margins and internal markup workings hidden. The view your owner-rep can take to the OAC.
Full register with reviewer findings
Everything above, plus the engine's findings per CO, your PM's decision, dollar deltas, and source citations. The audit trail you keep in your project file in case of dispute.
Optional: auto-generate the CO section of your monthly owner report from the register. Pulls the period's approvals, current pipeline, and forecast impact into a one-page narrative the owner can read in 90 seconds.
What this engine actually saves.
By our estimate, a $24M GMP project sees about 38 change orders over its life. What a first-pass engine review tends to find on a project like that — our estimates, not measured results:
~3% of CO lines
Transcription mistakes, unit-price miscalcs. Caught manually by good PMs maybe 30% of the time.
~12% of COs
Where markup exceeds the agreed cap by 1–5 points. Easy money. Most firms either notice or don't depending on who's reviewing that week.
~8% of CO dollars
The big one. Sub adds work that was already in their base scope. Hardest to catch because it requires re-reading the original subcontract — which most PMs don't have time for.
~$0.4–1.8M / year
On a portfolio of 6–10 active jobs. The number scales with portfolio size; the engine's value scales with it linearly.
~6 hr / CO of PM time
Reading the contract, cross-checking the schedule, pulling T&M logs, computing the math. The engine does the first pass in 45 seconds; the PM verifies the findings in 4–6 minutes.
Faster monthly close
Project meetings spend less time arguing about whether a CO is valid — because the reviewer's brief already shows the work. Owners report higher confidence in the CO log over time.
Numbers above are our estimates, not measured results or guarantees. Recovery varies by project size, subcontractor mix, and how aggressively your firm currently challenges COs.
It works alone. It's better in a chain.
CO Review reads cleanly on its own, but the cross-checks — the part that actually saves money — require the other engines feeding it.
- Contract Review — supplies markup caps, T&M rate ceilings, change-order procedure constraints.
- Schedule Risk — checks a CO's claimed delay against the activity's real critical-path status in your current schedule.
- Procurement — surfaces T&M and pay-app overlaps that turn into "already paid" findings.
- Pay App Review — the next time the sub bills, the approved CO amount carries forward and gets verified line-by-line.
Things everyone asks first.
What CO formats does this read?
AIA G701, AIA G701/CMa, ConsensusDocs 717, plus any PCO submitted as PDF, Excel, or Word. Custom proprietary forms get auto-mapped to a common schema. If your sub sends it as a JPEG or a scan, there is no text to read — there is no OCR on this path, so the run is refused rather than pricing a change order from a document nothing could read. Ask them for the native PDF, Excel or Word file.
Does it touch the approval flow itself?
No — this is a review tool, not an approval router. The output is a reviewer's brief. Your PM, project executive, or owner approves the CO through whatever flow you use today (Procore, manual signatures, e-signature platform). Most firms run the engine as a checkpoint before the formal approval step.
How does it know what's "scope in base"?
Pulls the executed subcontract from the project's documents, parses the scope language — including any drawing sheet numbers or details it cites in text — and maps CO descriptions against that scope. It reads the contract's own wording, not the drawing files themselves; a real image-level cross-reference against base drawings is on the roadmap, not in the product today. Confidence drops when the base scope is itself ambiguously written — flagged "verify with PM" rather than firmly denied.
Can the engine review owner-side COs too, not just sub COs?
Yes. Same flow, perspective flipped. The owner's CO to the GC gets reviewed against the GMP contract, schedule float ownership, and any markup the prime contract allows. Useful when you're pushing a CO upstream to the owner and want to make sure your own paperwork doesn't have soft spots.
What happens if a PM disagrees with a finding?
The engine's output is evidence for your team to weigh, not a verdict — you can still Approve, Reject, Negotiate, or create a follow-up Task on the CO no matter what it flagged. If the CO or the underlying scope documents get revised, re-run the engine for a fresh read against the current paperwork. There's no persistent per-finding override today — every run judges what's actually on the page.
Bring a stack of PCOs to a 15-minute call. We'll review them on screen.
Live demo with your real subcontract and three or four real PCOs from a recent job. You keep the output. Disputed dollars from a working project usually pay for the call several times over.
Try Free for 14 Days →