Underbilling: how to find it before it compounds

Guide · 7 min read · Updated July 2026

Underbilling is invoicing a customer less than the signed contract entitles you to — the wrong rate, a missed price increase, a product delivered but never added to the bill, an amendment that raised the fee and never reached the billing system. It is the quietest form of revenue leakage: the work is delivered, the cost is incurred, and the shortfall repeats on every invoice until someone finds it.

Why underbilling hides

Overbilling gets caught fast, because the customer catches it. Underbilling has no such alarm:

Customers don't report being undercharged. An invoice that is too high triggers a dispute within days. An invoice that is too low gets paid without comment. Your most reliable external error-checker only works in one direction.
Finance sees paid invoices, not unbilled deltas. Standard financial controls reconcile invoices issued against payments received. An underbilled invoice passes every one of those checks — it was issued, it was paid, the ledger balances. The gap between what was invoiced and what the contract says should have been invoiced appears in no report, because no system holds both sides of that comparison.
Every system agrees with every other system. Billing matches the CRM, the CRM matches the order form, revenue recognition matches billing. They can all be consistently wrong together, because they were all populated from the same re-keyed record — not from the signed document.
It compounds. A missed uplift understates the base that next year's uplift applies to. An amendment that never reached billing gets renewed at the wrong number. The longer it runs, the bigger the gap and the harder the eventual customer conversation.

The usual causes

Underbilling is rarely one big mistake. It is the accumulation of small structural gaps between the contract and the systems downstream of it — and every re-key between them is a chance to drift:

Quote-vs-signed drift. Negotiation changed the deal after the quote — but billing was set up from the quote or the CRM record, not from the executed document. The signed price, term or scope never made it into the systems.
Missed uplifts and escalations. The contract entitles you to an annual increase; billing keeps charging last year's number. This is common enough to deserve its own guide: contract uplifts and annual price increases.
Usage tiers billed at old rates. The customer crossed into a higher tier — more users, more volume, more documents — but the rate table in billing still reflects the tier they started in, or the overage clause was never configured at all.
Amendments that never reached billing. Upsells, mid-term expansions and repricings get signed months after go-live, handled by different people, and reach some systems, sometimes. The amendment is the single most likely document in the chain to be lost between legal and billing.
Co-term and proration confusion. When an expansion is co-termed to the original agreement, someone has to compute a prorated charge and a new combined renewal value. Manual proration is a reliable source of undercharging — and the error then bakes itself into the renewal baseline.

How to find it: the contract-vs-invoice audit

There is exactly one test that detects underbilling: compare what you invoiced against what the signed contract says you should have invoiced. Line by line, contract by contract. Here is the audit, step by step:

Pick the sample — most-amended contracts first. Don't sample randomly. Rank customers by number of amendments, then by contract value and age. Every amendment is a re-keying event, so the most-amended contracts are where drift concentrates. Ten to twenty contracts is enough to establish whether you have a problem.
Assemble the full contract stack for each. The original agreement plus every amendment, order form, side letter and co-term. Underbilling often hides precisely in the documents that aren't in the folder.
Build the "should-bill" record. From the documents, write down what the customer should currently be paying: line items, rates, quantities, tier thresholds, escalations applied to date, payment schedule. This is contract data extraction, done manually for the audit — the slowest step, and the reason these audits are usually done once and never repeated.
Pull twelve months of invoices and compare. Match each invoice line against the should-bill record. Flag every delta: wrong rate, missing line, unapplied uplift, tier mismatch, missed one-off charge.
Classify each miss by cause. Quote-vs-signed drift, missed uplift, stale tier, lost amendment, proration error. The classification tells you which process is broken — which matters more than the individual recoveries.
Extrapolate honestly. If a meaningful share of a deliberately-biased sample shows underbilling, the unsampled base has it too. Industry analyses of revenue leakage regularly put the total at a material percentage of contracted revenue; your own audit is the only number that actually applies to you.

Fixing it permanently: reconciliation, not annual audits

The audit finds the backlog. It does not stop the leak, because the causes — re-keying, amendments, untracked escalations — carry on the day after the audit ends. An annual audit means every new error runs for up to a year before detection, and the manual should-bill step is painful enough that "annual" often becomes "once".

The permanent fix is to make the comparison continuous: keep an always-current extraction of every signed contract and amendment, reconcile it against CRM, ERP and billing as a standing loop, and surface each mismatch when it appears — before the next invoice goes out, not twelve months of invoices later. That is contract data reconciliation run as infrastructure rather than as a project, and it converts underbilling from an archaeology exercise into an exception queue.

Common questions

How far back should we audit? For detection, twelve months of invoices per contract is usually enough to catch every repeating error, since underbilling recurs on each cycle. For recovery, the practical limit is commercial rather than legal: statutes of limitation typically allow you to go back years, but the further back you reach, the harder the customer conversation. Most teams quantify the full history for the biggest gaps and correct forward for the rest.

How do we handle the retro-invoicing conversation with customers? Directly and early. Lead with the contract: "our audit found we've been invoicing below the agreed terms — here is the clause, and here is the corrected amount." Most customers accept a documented correction, particularly going forward; arrears are more negotiable. Offer to walk through the source clauses, consider spreading large arrears, and fix the forward billing immediately regardless of how the arrears conversation lands.

When does writing it off beat clawing it back? When the recoverable amount is small against the relationship at stake — a modest arrears claim into a strategic account near renewal is rarely worth it. Sensible tests: is the amount material, is the contract clause unambiguous, is the account healthy, and is the relationship senior enough to absorb the conversation? Whatever you decide about the past, always correct the future — writing off arrears is a commercial choice; continuing to underbill is just an ongoing donation.

Where TrustedIQ fits

TrustedIQ is contract-to-cash intelligence: it extracts the current commercial terms from every signed contract and amendment into one source-linked record — the should-bill position the audit builds by hand — and continuously reconciles it against your CRM, ERP and billing systems, flagging every delta as it appears. It doesn't send invoices or decide the claw-back conversation; it makes sure you find each underbilled line on the first affected cycle instead of the twelfth. Book a demo.