Techbanq

Software · recovery

Stop asking when it will be done; ask what verifiably works today

A build that has eaten its budget without shipping needs a different question than the one that got it here. Progress reports measured in percent complete led to this point; the way out is measured in working software — what runs end to end today, what that proves, and whether finishing, descoping or stopping serves the business best from here.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

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

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

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.

VariableEffect on priceWhy
Unbounded scopeThe project grows faster than it shipsNothing 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 complexityThe estimate was for a simpler system than reality holdsThe 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 estimationThe plan was a best case wearing a schedule’s clothesEstimates 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-planningThe plan and the project stopped describing the same thingChanges 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.

OptionWhen it is the right callWhat it demandsThe risk it carriesBest for
Finish as scopedThe 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 outcomePart 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 salvageThe 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.

STAGE 01

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.

STAGE 02

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.

STAGE 03

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.

STAGE 04

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

  1. 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.

  2. 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.

  3. 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.

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