- Market
- Saudi Arabia
- Written for
- CTO, COO, Founder
- Decision
- Decide what to do with a software build that has overrun its budget without finishing
- Languages
- EN · AR
Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The post-mortem, done early
The four leaks that drain a software budget, in the order they usually strike
Overruns are overdetermined — more than one of these is usually at work. Naming which ones apply to your project matters, because each points to a different recovery move.
| Variable | Effect on price | Why |
|---|---|---|
| Unbounded scope | The project grows faster than it ships | Nothing was ever refused, so the target moved with every stakeholder meeting. The tell: the requirements list is longer now than at kick-off, and nobody can name a feature that was cut. A budget cannot hold against a scope that will not. |
| Undiscovered complexity | The estimate was for a simpler system than reality holds | The legacy data was dirtier than assumed, the integration partner’s interface was undocumented, the approval workflow had exceptions nobody mentioned. This leak hides inside the others: it looks like slow progress when it is actually true scope surfacing late. |
| Optimistic estimation | The plan was a best case wearing a schedule’s clothes | Estimates made to win approval, or made from the happy path with no allowance for rework, testing and the integration weeks every real system needs. The tell: every phase finished “ninety percent” on time, and the last tenth of each has consumed the reserve. |
| Change without re-planning | The plan and the project stopped describing the same thing | Changes were accepted — reasonably, individually — but the budget and timeline were never re-baselined to absorb them. The project is then measured against a plan for a product it is no longer building, and the gap reads as failure when part of it is unacknowledged change. |
The decision
Finish, descope or stop — the triage nobody wants to run
Sunk cost argues for finishing; frustration argues for stopping; neither is an analysis. The comparison below is one, and it only works when run against what verifiably works today rather than against the plan.
| Option | When it is the right call | What it demands | The risk it carries | Best for |
|---|---|---|---|---|
| Finish as scoped | The remaining work is genuinely small and verified — running software, not status-report percentages — and the full scope still earns its cost against today’s business case, not the original one. | A re-estimate from evidence, a scope freeze for the remainder, and progress re-measured in working end-to-end slices. | The same optimism that caused the overrun approving one more optimistic plan. If “nearly done” has been true for months, it is not true. | A build that is verifiably close, still worth its full scope. |
| Descope to the outcome | Part of the scope carries most of the business value — usually one or two workflows — and shipping that part soon beats shipping everything eventually. This is the right call more often than either extreme. | A ranking of scope by business outcome, the discipline to park the rest, and a release that puts the kept slice into real use quickly. | The parked scope creeping back in before the core ships. A descope that refuses nothing has decided nothing. | A build whose value concentrates in a fraction of its scope. |
| Stop and salvage | The remaining cost exceeds the value of what would ship, the business case has moved, or the foundation is unsound enough that finishing means rebuilding. Money already spent is not a reason to spend more — it is gone either way. | Courage, plus a salvage pass: components, integrations, data models and the lessons themselves often carry forward into whatever comes next. | Stopping the project but not the need — the underlying business problem remains and deserves a properly scoped answer, or the same project restarts in two years. | A build whose completion no longer pays, whatever was sunk. |
The recovery
Recovery starts with a walking skeleton, not a new plan
When the decision is to finish or descope, the first deliverable is not a revised Gantt chart. It is the thinnest slice of the system that runs end to end — because that slice converts every remaining unknown into a known.
Stand the skeleton up
One real transaction through every layer — interface, logic, data, each integration — deployed to a production-like environment. Thin everywhere, faked nowhere. This forces the risky parts to reveal themselves first instead of last. Proof the architecture holds, and the true difficulty of what remains.
Rank the remainder by outcome
Remaining scope is listed against the business outcome each item serves, and sequenced so the most valuable workflow completes first. Anything serving no nameable outcome goes to the parked list in daylight, not by quiet omission. A backlog where position means value, not arrival order.
Re-estimate from the skeleton’s evidence
The remaining work is estimated from what building the skeleton actually took — real velocity against this codebase, this data, these integrations — not from the original plan’s assumptions. The number is usually sobering, which is the point. An estimate the sponsor can finally rely on.
Ship in slices, re-plan on change
Each subsequent slice lands in real use, so progress is measured in working software from here on. Changes remain welcome — but each one now visibly re-prices the plan, which is what was missing the first time. A project that cannot silently diverge from its budget again.
Our role
An outside team’s usefulness in a rescue is its lack of history
- 01
The assessment nobody inside can give
Everyone inside a troubled project has a position to defend. We arrive without one, and read the codebase, the backlog and the history for what they are — including the finding, when true, that the work is better than its reputation and the problem is planning, not engineering.
- 02
The triage, priced honestly
We put numbers and evidence behind each of finish, descope and stop — what each costs from here, what each delivers, what each risks — and we state a recommendation rather than hiding behind the options.
- 03
Delivery that rebuilds trust
If we take the recovery on, the walking skeleton comes first and every report thereafter is demonstrable software, because a rescued project cannot afford a second credibility collapse.
Whether to keep investing is a business judgement that stays with you, as does the next contract — though we will say plainly what it should fix: outcome-scoped phases, change that re-prices the plan, and progress defined as working software rather than reported percentages.
Common questions
What buyers ask
Is it ever right to cancel the project and write the spend off?+
Yes — when the remaining cost to finish exceeds the value of what would ship, when the business case has moved on, or when the foundation is unsound enough that finishing is really rebuilding. The money already spent is irrelevant to this decision, which is the hardest part to accept: it is gone whichever way you choose, so only the forward-looking comparison counts. Cancellation done well includes a salvage pass — components, data models, integrations and hard-won lessons usually transfer — and an honest note that the business need survives the project and will want a properly scoped answer later.
How do we finish the build without simply pouring in more money?+
By changing what the next money buys. More funding into the same process buys more of the same overrun; the recovery pattern changes three things first. Progress gets redefined as working software — a walking skeleton through every layer, then slices landing in real use — so status can no longer drift from reality. Scope gets ranked by business outcome and frozen for the remainder, with everything else parked in daylight. And the remaining estimate is rebuilt from evidence, from what the skeleton actually took to build against this codebase and these integrations. Money spent inside that frame finishes things; money spent outside it extends the overrun.
What should the next software contract say so this does not happen again?+
Four things, whoever builds. Phases scoped by business outcome, each ending in software in real use — never in documents or percentages. A change mechanism that welcomes change but re-prices the plan visibly each time, so scope cannot grow while the budget officially stands still. Acceptance defined as demonstration: a phase is done when its workflow runs end to end in your environment, on your data. And an early exit that both sides can afford, with code, documentation and data yours at every stage — because a contract you can leave keeps everyone honest, and a contract you cannot leave is how one overrun becomes three.
In this cluster
Get an honest read with us
An independent assessment of the stalled build that states what works, what remains, and a costed recommendation across finishing, descoping and stopping.
Start the conversation