How Much Does It Cost to Rescue a Stuck Software Project?

The Question Everyone Asks First

"How much to fix it?"

It's the first thing a founder asks me when their project is stuck — before I've seen the repo, before I know what "it" even is. And I get why. They've already spent money they can't get back, the launch date slipped twice, and now they need a number to decide whether to keep going or walk away.

Here's the honest answer: rescue quotes for the same project routinely swing from $4,000 to $80,000 depending on who you ask and what they assume. That range isn't padding — it reflects genuine uncertainty that nobody can price away until someone actually reads the code.

So instead of giving you a fake number, let me show you how I build a real one.

Step Zero: The Audit (and why I charge for it)

I don't quote a rescue off a phone call. I quote it off an audit — usually 2 to 4 hours of reading the codebase, running it locally, checking the git history, and mapping what's built against what was promised.

I charge for that audit. Typically $500 to $1,500 depending on project size. Founders sometimes balk at paying for "just a report," so here's why I insist:

• A free quote forces me to guess high to protect myself. You pay for that guessing in the final number.
• The audit is often the first honest accounting of what they actually paid their last dev for.
• If they hire me for the rescue, I credit the audit against the project. It costs them nothing extra.

If someone quotes you a full rescue price without reading the code first, they're either lowballing to win the deal (and will "discover" more work later) or padding heavily. Neither is what you want.

The Four Factors That Move the Number

Once I've done the audit, four things determine the price. Every rescue I've done comes down to some combination of these.

1. How much of it is salvageable

This is the biggest lever by far. The question isn't "is the code good" — it's "is it faster to fix or faster to rebuild?"

What I find	What it means for cost
Solid foundation, missing features	Cheapest. I'm building, not untangling.
Working code, bad architecture	Medium. Refactor as I go.
Business logic tangled into UI everywhere	Expensive. Fixing one thing breaks three.
No separation of concerns, any everywhere	Often a partial rewrite is cheaper.

A project that's 70% built on a decent foundation might cost $5,000–$12,000 to finish. The same feature set on a foundation that has to be rebuilt can hit $30,000+ — because I'm not finishing a project, I'm building a new one while keeping the old one alive.

2. How stuck it actually is

"Stuck" covers a lot of ground. I sort it into three buckets, and each prices differently:

• Stalled but working — the last dev left, but what exists runs. I'm picking up where they stopped. Lowest cost.
• Broken in production — it shipped, it's live, and it's failing users right now. This carries urgency premium and risk. Higher cost.
• Never worked — demo-grade code that fell apart the moment it met real traffic or real data. Highest, because "fixing" it usually means building the production layer that was never there.

That last category is the one people underestimate most. A demo that impresses stakeholders and a product that survives 500 concurrent users are different amounts of work by an order of magnitude.

3. Scope discipline — theirs and mine

The fastest way to blow up a rescue budget is to treat it as a chance to add everything that was ever wished for. I don't. A rescue has one job: get the thing working and shippable. New features come after, quoted separately.

I'm blunt about this with clients because it protects their money. When someone says "and while you're in there, can we also add X," my answer is usually "yes, after launch, as a separate line item." Mixing rescue work with new-feature work is how a $10,000 project quietly becomes a $40,000 one.

4. How fast they need it

Urgency is real and I price it honestly. A normal timeline is a normal rate. "We have a customer demo in nine days" means I'm rearranging my other commitments and working evenings, and that carries a premium — usually 15–30% on top. I'd rather name that upfront than pretend deadlines are free.

Three Real Shapes of a Rescue

To make this concrete, here are three composite examples based on the kinds of projects I actually take on. Numbers are illustrative, but the ranges are honest.

The Almost-There MVP — ~$6,000 A founder had a Next.js app that was 80% done when their contractor ghosted. Auth worked, the dashboard rendered, but payments were never wired up and there was no error handling anywhere. Two weeks of work: finish Stripe, add the production infrastructure, ship. Clean foundation meant most of the budget went into building, not untangling.

The Broken Launch — ~$18,000 An e-commerce build that went live and immediately buckled — slow pages, checkout failing intermittently, no logging so nobody knew why. Four to five weeks: diagnose the failures, fix the architecture causing them, add the observability that should have been there, then harden it. Higher cost because it was live, losing sales, and I was operating on a foundation I hadn't chosen.

The Rebuild-in-Disguise — ~$45,000 "We just need it finished." What I found was a demo dressed as a product: business logic pasted into components, no tests, no data layer, any types throughout. Finishing it would have taken longer than rebuilding it properly, and I said so in the audit. We rebuilt the core over about ten weeks, reusing what we could of the UI. This is the one people don't want to hear about — but pretending it's a quick fix helps nobody.

What You're Actually Paying For

The code is rarely the expensive part. What you're paying for in a rescue is judgment: the ability to walk into a stranger's codebase, figure out fast what's worth keeping, and give you a straight answer about the cheapest path to a working product.

That straight answer is the whole point. Most stuck projects didn't fail because the idea was bad. They failed because the wrong dev was hired, scope wasn't managed, or nobody told the founder the truth until it was too late.

How to Get a Real Number for Your Project

If you want an actual quote instead of a range, the path is short:

1. Tell me what stuck — what was being built, what happened, what "done" looks like.
2. Give me access — repo, environment, whatever docs exist.
3. Let me audit it — a few hours of reading, then a report: what works, what's broken, what to rebuild, and a real timeline and cost.

You get the audit whether or not you hire me for the rest. It's yours — proof that someone finally read the code and told you the truth about it.

If your project is stuck and you want a straight answer on what it'll cost to finish, let's talk.