The money you already spent on failing software is gone, whatever you decide next. So it can't be a reason to keep paying.
The only question left is what the next payment buys. Give the existing code two weeks: if a real customer can complete the core action, refactor it. If not, rebuild a small version.
This guide explains why founders keep paying for dead code, and gives you the two week test. It also shows what a small rebuild looks like, and what to secure before you decide.
What does the sunk cost trap look like in software?
Picture a common case. A founder paid an agency for over a year. The app crashes on login, has no working payment flow, and has never had a real user.
The founder's request: "We already paid so much, we just need someone to finish it."
They don't need someone to finish it. They need someone to say that the money is gone whether they continue or not. The only question is what the next payment buys.
It is like staying in a cinema watching a bad film because you paid for the ticket. The ticket is spent either way. The only choice is whether you also spend the next two hours.
What is the sunk cost fallacy?
The sunk cost fallacy is continuing to invest in something because of what you already spent on it. The right question is what it will return from here.
It is one of the best documented biases in behavioural economics. In 1985, Hal Arkes and Catherine Blumer showed it with theatre tickets. People who paid full price for a season pass went to more plays than people who got a random discount, though both had already paid (Arkes and Blumer, 1985).
Underneath sits loss aversion: a loss hurts about twice as much as an equal gain pleases (Tversky and Kahneman, 1992). Writing off a failed project does not feel like an accounting entry. It feels like a personal loss, proof that you chose the wrong agency.
So the founder protects their pride instead of their cash. They call the next payment "finishing" because it sounds like recovery. In reality it is the same bet again, with less money in the bank.
The most expensive code in any startup is the code written to justify a past mistake.
What are the warning signs of a dead software project?
- Monthly payments with no shipped feature. Money tied to time, not to something working in front of real users.
- A beautiful design and an empty backend. The mockups look finished, so the founder believes the product is nearly done. The database has three tables and no security rules.
- A rewrite already happened once. The agency changed technology halfway, so half the budget paid for code that no longer exists.
- Nobody on the founder's side can read the code. Every update is a promise, never a link.
None of this means the founder was foolish. They were buying effort when they should have been buying evidence.
Should you refactor or rebuild?
Rewrites have a bad reputation, partly earned. Joel Spolsky's famous essay on Netscape warns that throwing away working code throws away years of fixed bugs and lessons (Spolsky, 2000). If your software works, has users and has just grown messy, you refactor it piece by piece.
But that warning assumes the code works. A project with no users has learned nothing. There is nothing to preserve except the invoice.
So use a simple rule. Give an experienced engineer two weeks with the code, and one question to answer.
Can a real customer complete the core action, end to end, in production, by the end of those two weeks?
| What you see after two weeks | What it means | Decision |
|---|---|---|
| The core flow works, the code is messy | The asset is real, the quality is not | Refactor in place |
| The core flow almost works, one part is broken | The structure is sound, one part is not | Replace that part only |
| Nothing works end to end, the data model is wrong | There is no asset, only spending | Rebuild small |
| Nobody can even deploy it | The agency was the only way to run it | Rebuild small, and own your hosting |
The two weeks cost something. They are the cheapest information you will buy all year.
What does a fast, small rebuild look like?
The rebuild must be small enough that it can't become the next sunk cost. My rule: three screens, one database, one way to pay.
| Part | What it means |
|---|---|
| Three screens | What it is, what you sell, and the action. If you need more to prove someone will pay, the scope is hiding a decision |
| One database | A managed Postgres such as Supabase, with access rules from day one so permissions live in the database |
| One way to pay | In Algeria, cash on delivery first. Card payment with a provider like Chargily comes later, once orders prove demand |
I explain the full cost logic in the 50,000 DA app formula, and why lean is not lazy in minimum viable, not minimum effort.
A rebuild like this ships in weeks, not seasons. It ships something a customer can use, which is the only thing that tells you whether more money is worth spending.
Why is the sunk cost trap sharper in Algeria?
The money is often family money. Writing it off is not only a financial loss. It is a conversation at the dinner table, which makes the pride cost larger than the number.
Getting money back is hard. A dispute over an unfinished app rarely ends with a refund, so "finishing" can feel like the only way to get something back.
The code is often not the founder's. Many founders never received the code repository, the server passwords or the store accounts. Before any decision, the first job is ownership: source code, domain, hosting, database, Play Store and App Store accounts, all in your name.
What mistakes do founders make with a failing project?
- Paying the next invoice to "finish" without a test. Run the two week test first.
- Mixing two questions. "Was this a mistake?" is about the past. "What does the next payment buy?" is about the future. Only the second one gets a vote.
- Accepting status updates instead of links. Every payment should be tied to something you can open on your phone.
- Rebuilding the same big plan. A rebuild with fourteen screens is the next sunk cost.
- Deciding before owning the code and accounts. You can't fix what you don't control.
What should you do this week?
- Today: list everything you don't own yet: code, hosting, domain, database, store accounts. Ask for all of it in writing.
- This week: ask an independent engineer for the two week test.
- From now on: tie every payment to a working feature you can open yourself.
- If the answer is rebuild: cut to three screens and refuse every feature that does not help a stranger pay you.
- Then: let real orders decide what to build next.
Why do expensive projects end up here in the first place? I explain it in why expensive apps die before launch.