Nobody Steals This Money. It Is Simply Never Asked For

Every system a contractor owns reconciles one pair of numbers: what was claimed against what was certified. The difference is chased, argued and eventually resolved, because both sides are documents and somebody is paid to compare them.

Almost nothing reconciles the pair that decides whether the job made money: what was built against what was claimed.

That second gap has no document on either side of it at the moment it opens. It produces no variance, no exception, no red line on any report. It does not appear in the accounts, because nothing was invoiced. It does not appear in the cost value reconciliation either, unless somebody deliberately puts it there — and to put it there you would have to already know it existed.

This is not the same problem as being paid late. Late money arrives. This money does not arrive at all, and the reason it does not is that it was never asked for.

Why a payment certificate is arithmetically perfect around a hole

Start with the mechanism, because the mechanism is what makes this permanent rather than merely annoying.

An interim payment certificate is cumulative. It states the value of everything executed since day one, then subtracts everything certified before it. That structure is correct, and it is also the reason an omission never surfaces.

If a line of work was never entered into the valuation, this month's cumulative figure is lower by that amount — and so the subtraction of last month's certified total produces exactly the right answer for the month. Next month, the same. Every certificate in the sequence is internally consistent. The arithmetic never disagrees with itself, because nothing in it compares the valuation to the site.

An invoice can be short and somebody notices, because there is an order it was supposed to match. A cumulative valuation cannot be short in any way the system can detect, because the valuation is the statement of what happened. There is nothing behind it to check it against.

So a missed item is not late. It is not queued. It is not in a pending state anywhere. On the day the certificate is issued, it stops existing.

The six places it actually leaks

Nothing on this list is exotic. Every one of them happens on well-run jobs, run by competent people, and that is the point — none of them looks like a failure while it is happening.

Where	What it looks like at the time
Instructed verbally, built the same week	Good service. The engineer asked, you did it, the relationship improved
Executed after the measurement cut-off	Normal. It goes in next cycle — and next cycle starts from its own cut-off
Discounted pending information, never re-claimed	Reasonable. The test result came two weeks later and the claim had moved on
Dayworks without signed sheets	Unavoidable. The supervisor who watched it is on another site now
Materials on site, claim never assembled	Administrative. It needs the invoice, the insurance, sometimes a vesting certificate
Prelims unchanged through an extension of time	Invisible. Time-related costs stayed flat while the time did not

The first one is the largest on most jobs, and it is the one this cluster covers in its own right: most variation money is lost before anyone argues about price. An instruction that was obeyed and never recorded cannot become a variation, a variation that does not exist cannot be valued, and a valuation that was never made cannot reach a certificate. Four links, and the chain broke at the first one, in a conversation.

The third is worth naming precisely because it looks like it self-corrects and does not. The consultant reduces an item pending an as-built, a test result or a signed sheet. The information arrives. But the next application is almost always built forward from the last certified figure rather than from the claim it was cut down from, so the reduction is inherited as though it were agreed. The one document that would have caught it — a comparison of applied against certified, line by line, carried forward — is exactly the document most contractors do not produce.

The question nobody in the business is asked

Here is the test, and it takes one minute.

Name the person in your company who is asked, every month, in writing: is there anything we built this period that is not on this application?

In most contracting businesses there is no such person. Not because anyone is careless — because it is nobody's job, no report asks it, and the people who would know the answer are the ones on site, who are measured on progress rather than on paperwork.

The commercial team can only work from what reaches them. The site team can only send what it has been given somewhere to put. Between the two sits a gap that is nobody's failure and everybody's loss.

That is the honest reason this is a systems problem rather than a discipline problem. Telling site staff to be more diligent has been tried on every job since the trade began. What has not been tried, on most of them, is making the record of an instruction cheaper to create than to skip — one screen, on a phone, by the person the engineer spoke to, at the moment he spoke.

What it is worth

We would rather point at one contractor's figures than at an industry average, because an average is a number nobody can check.

Blue Spark Electromechanical, an MEP contractor in Business Bay, published their first twelve months after go-live with us. Of the AED 2,995,000 recovered, AED 715,000 was variations that had previously been swallowed — instructions recorded from a phone on the day they were issued, priced, and carried to the next certificate.

None of it was new revenue. All of it was work they had already built, already paid for, and were giving back.

That is one company, on their own jobs, and it is not a promise that your figure is the same. It is evidence that the figure is not zero, which is the assumption the absence of any report quietly encourages.

The wider number, across five contractors over two years, is AED 28.4 million of work built and never certified. That is an aggregate — five businesses, two years — not a figure for one job or one year, and it is quoted here as evidence of scale rather than as a benchmark for yours. What it establishes is only this: on the jobs where somebody finally ran the comparison, the answer was never nil.

If you want the arithmetic on the other end of the same chain — what is being held from you and when each instalment falls due — the retention release calculator does it from your own contract terms rather than from a convention.

What to make a vendor show you

Ask for these in a live system on a real contract, not on slides.

1. Record an instruction from a phone, on site, and show it appear in the commercial team's list the same minute.
2. Price that instruction and carry it onto the next payment application without anyone retyping it.
3. Produce a list of work executed in the period that is not on the current application.
4. Show applied against certified, line by line, cumulative, with the shortfall on each line.
5. Take an item that was discounted pending information, attach the information, and re-claim it — and show that the next application starts from the claim rather than from the reduced certified figure.
6. Show materials on site claimed with their evidence attached, not as a manual line.
7. Show the same completeness check across every live project on one screen.

Item 3 is the one that decides it. Every system can tell you what you claimed. A system that can tell you what you built and did not claim is answering a different question, and it is the only question on this list that has money behind it right now rather than next month.

Item 5 is the quiet one. Most systems pass items 1 to 4 and fail this, because carrying the certified figure forward is the easier thing to build and the wrong thing to build.

The short version

Work gets built and never billed for, on good jobs, run by good people, because the chain from instruction to certificate has four links and the first one is a conversation.

A cumulative payment certificate cannot detect the omission, because it has nothing behind it to check itself against. The accounts cannot detect it, because nothing was invoiced. The reconciliation cannot detect it, because it starts from the claim.

The only thing that finds it is a comparison nobody currently makes — built against claimed — and the only way to make that comparison cheap is to capture the instruction at the moment and place it is given.

We showed that chain running end to end, on one contract, at Odoo's Construction Business Show: BOQ, measurement, certificate, retention, variation, subcontractor account, PINT AE e-invoice. The recording is here.

What it looks like built as one system rather than six is on the contracting page, and the honest map of where standard Odoo stops is here. The system itself is Movinti, and its answer to this particular problem is a refusal rather than a reminder: a site instruction carrying a cost impact cannot be closed until a variation exists against it, so the work cannot go quiet the way it did before.