Every discovered dependency generates an invoice

Because the base contract is the loss leader. A systems-integrator engagement is priced to win, then earns its margin on the change requests that discovery makes inevitable. A monthly run rate of $30,000 to $50,000 looks tolerable until change requests add 20-30% on top and the true cost settles at two to three times the original budget. The mechanism is structural, not villainous: on a scope-and-invoice model, every dependency you find mid-build becomes a new line item.

Why does the base contract understate the cost?

Start with the sticker price. Independent commentary on the model puts a typical enterprise SI engagement at $30,000 to $50,000 a month, with change requests that routinely add 20-30% of the base contract value and a true cost that exceeds the project budget by two to three times. That reading comes from a single vendor with an interest in the framing, so treat the exact multiple as illustrative rather than an industry benchmark. It matches what we see in the field anyway. The problem is not that estimates are careless; it is that the estimate is written before anyone has read the code.

Every discovered dependency generates a change request, and every change request generates another invoice.

That sentence is the whole business model in one line. A fixed-scope statement of work assumes the integration surface is known on day one. It never is. The moment a build touches a legacy pricing table, an undocumented tax rule, or a returnables ledger that no team owns, the work is real but out of scope — and out of scope means a change request.

What does an SI hour actually cost?

The run rate makes more sense once you see the labour rates behind it, and those are not secret. US federal schedules publish awarded rates. As of October 2025, on the GSA schedule a Deloitte consulting management executive is billed at $373 an hour and a senior consulting staffer at $257.62. The same public data set, the GSA CALC tool, puts the average awarded software-engineer rate at $124 an hour across all vendors — a blunt reminder of the gap between what an engineer costs and what a brand-name firm charges for one.

Commercial day rates tell the same story. Industry trackers put a Deloitte director at $1,200-2,500 a day and offshore delivery staff at $100-350 a day as of October 2025. Blend the pyramid — a few expensive partners, a layer of managers, a base of offshore developers — and a working rate near $200 an hour is a fair mid-point for a mixed onshore/offshore team.

Why do change requests multiply instead of taper off?

You would expect discovery to front-load the surprises, so that change requests slow as the system stabilises. On the SI model they tend to do the opposite, for three structural reasons.

The estimator profits from the estimate being wrong. The party that scopes the work is the party that bills the overrun. No bad faith is required for that incentive to bend every ambiguous case toward 'new scope'. When 'is this in the statement of work?' is a revenue question for the firm answering it, the answers trend one way over a few hundred tickets.

The context lives outside your building. Every dependency the integrator uncovers is knowledge it now holds and you do not. The formal remedy — a knowledge-transfer phase near go-live — mostly does not survive contact with reality; we have written before about how knowledge transfer decks are where context goes to die. So the next change request lands on the only party who understood the last one, and the dependency compounds instead of clearing.

Every seam between vendors is a change request waiting to happen. Large programmes rarely run on one integrator. Order capture, billing, delivery and analytics each get an owner, and the interfaces between them belong to no one until something breaks. We have costed those seams in the meeting that costs more than the feature: every 'who owns this field?' becomes a cross-vendor change request carrying two markups instead of one.

What does the arithmetic look like over a year?

Put one person through it. A senior integrator developer at a blended $200 an hour, over a working year, costs on the order of €350,000-400,000 fully loaded. The equivalent in-house senior engineer runs €120,000-160,000 loaded. That is roughly two-and-a-half times the cost per head before a single change request is raised — and change requests are, by design, raised.

Now multiply by a team, layer on the 20-30% change-request uplift, and stretch it across a multi-year programme. The 2x-3x overrun stops looking like weak project management and starts looking like the intended output of the pricing model. The uncomfortable part is that the spend does not even guarantee adoption: a programme can clear nine figures and still ship something the field refuses to use — see the $125M order system reps refused to use. The invoices clear regardless of whether anyone logs in.

The fix is not tighter change-control paperwork; it is removing the incentive that manufactures the changes. Owning the context in-house — a small, AI-augmented team that holds the domain knowledge instead of renting it back one change request at a time — changes what a discovered dependency costs. When the engineer who finds the tax-rule edge case already maintains the pricing service, that dependency is a Tuesday, not an invoice. It is the model we run as a scoped pilot rather than a multi-year statement of work.

Rate cards will keep climbing and discovery will keep finding dependencies; neither is going away. What is shifting is the assumption that the two must be coupled. As more brewers move their route-to-market platforms onto teams they staff rather than firms they retain, the number worth watching is not the day rate — it is how many change requests never get written because the context never left the building.