Skip to content

How to Rescue a Stalled Build

The first move on a stalled build is never to write code — it’s to find out where the build actually is, because almost nobody involved knows, including the people building it. A stall is rarely a coding problem. It’s an information problem: the project has drifted somewhere nobody can see clearly, and until you establish the true position, every decision about what to do next is a guess.

That’s the answer. Here’s how I find the real position, why “how much is left” is the only question that matters, and how to tell whether to push on or cut it loose.

A stall is a visibility failure before it’s a technical one

When a build goes quiet — demos stop, deadlines slip a second and third time, updates get vaguer — the instinct is to assume the code is broken and throw more developers or more hours at it. That’s almost always wrong, and it’s wrong in an expensive direction. You can’t fix a position you can’t see. Adding effort to a build you don’t understand just spends faster in an unknown direction.

What’s actually happened in most stalls is that the gap between what’s reported and what’s real has quietly widened. The status updates say 80% done. The 80% is the easy 80% — the screens that demo well. The remaining 20% is the integration, the edge cases, the data migration, the error handling, the parts that don’t demo and don’t get shown, and that 20% is two-thirds of the actual work. Nobody lied. The reporting just tracked the visible part, and the visible part finished first. The project isn’t 80% done; it’s been 80% done for two months, which is the signature of a build that’s run out of the easy work and hit the hard part with no plan for it.

So the rescue doesn’t start with code. It starts with making the invisible visible: getting the real position out of the codebase and into the open, where it can be decided about.

How I find the true position

Establishing where a build actually is takes a structured look, not a status meeting. Status meetings are where the optimistic version lives. The real version is in the code, the commit history, and a few direct questions the team usually hasn’t been asked.

I read the codebase for what’s genuinely there versus what’s scaffolded — a screen that looks finished but is wired to fake data is not done, and a surprising amount of “nearly there” is exactly that. I look at the commit history for the shape of the slowdown: is work still happening and just getting harder, or did it quietly stop weeks ago? I separate the build into the parts that demo and the parts that don’t, and I get an honest count of how much of the unglamorous, doesn’t-demo work — the integration, the migration, the error paths — is actually finished. That’s where the truth hides, because it’s the part nobody shows.

Then I ask the team the question they’re rarely asked directly: what are you stuck on? Not “how’s it going” — what’s the specific thing that’s been hard for the last three weeks. Developers usually know exactly where the project is bleeding time. They’re just never asked plainly, or they’re asked in a room where admitting it feels like failure. Asked straight, by someone who can tell whether the answer is reasonable, they’ll tell you. That single honest answer is often the whole diagnosis.

The output of all this is one number that matters: how much real work is left. Everything else — whether to continue, restart, switch teams, cut scope — flows from that number, and you cannot make any of those calls honestly without it.

The decision once you know where it is

Once the true position is on the table, the rescue resolves into one of a few clear calls, and which one is usually obvious from the number.

If there’s a competent build that’s genuinely most of the way there and stalled on a specific, nameable blocker — a hard integration, an architectural corner they coded into, a person who left — you push on. You clear the blocker, often with a few days of senior help, and finish the build that exists. This is the good outcome and it’s more common than the panic suggests.

If the build is real but badly scoped — half-done because it was trying to do three times what it needed to — you don’t finish it, you cut it. Strip the project back to the smallest thing that solves the actual problem, ship that, and bank a working system. Most stalls that look hopeless are just overscoped, and a stalled build that’s been ruthlessly re-scoped is suddenly a few weeks from shipping. The code wasn’t the problem; the brief was.

If the build is genuinely bad underneath — wrong foundations, unmaintainable, every fix breaking two things — then continuing is throwing money after a sunk cost, and the honest call is to take what’s been learned and rebuild the core lean. That’s a hard conversation and I’ll have it straight, because pretending a broken foundation is salvageable to spare feelings is how a stalled build becomes an abandoned one.

The question almost nobody asks during a rescue

In the panic, everyone asks “how do we finish this.” The better question is “what did this build actually need to be.” A stalled project is very often a project that was never scoped to ship in the first place — it was scoped to impress, or to cover every possible future need, and it collapsed under its own weight. The rescue is then less about coding and more about finally answering the scoping question that should have been answered at the start. Back up to the real problem, cut the build down to it, and the stall frequently solves itself.

A pattern I see

The recurring one: a build that’s been “two weeks away” for three months. Every status update, two more weeks. The founder can’t tell if they’re being strung along or if it’s genuinely just always two more weeks of bad luck. The team isn’t lying — they genuinely believe it’s two weeks away each time, because each time they can see the next two weeks of work and not the wall of integration behind it.

The diagnosis is almost always the same: the demo-able work finished long ago, and the project has been stuck against the doesn’t-demo work the whole time, with no one tracking it because no one was counting it. The fix isn’t more time. It’s making that hidden work visible, counting it honestly, and either resourcing it properly or cutting the scope so it isn’t needed. “Two weeks away for three months” is not a timing problem. It’s an unseen-work problem, and it stays unsolved exactly as long as it stays unseen.

Who this isn’t for

If your build slipped by a fortnight once and the team gave you a clear, specific reason, you don’t have a stall and you don’t need a rescue — you have a normal project with normal variance, and parachuting in an outside diagnostician will just rattle a team that’s fine. This is for builds that have slipped repeatedly and gone genuinely opaque.

The call, in one line

Don’t add code to a stalled build — find out where it actually is first, because the stall is a hidden-work problem until proven otherwise.

This is one of my playbooks. It connects to how to scope an MVP — most stalls are overscope problems wearing a coding disguise — and when you actually need a fractional CTO, because the reason you couldn’t see the stall coming is usually that nobody senior was watching the build. The engagement for this specific situation is project rescue.

If your build has gone quiet and you genuinely can’t tell where it is, tell me about it — the diagnosis is usually faster and less alarming than the silence makes it feel. And if the rescue reveals you need a full team to rebuild and run the thing properly, that’s what my agency, Digital Royalty, is for.