23 deleted repos. Some hadn't been touched in four years. Most never saw a single user. This is a post-mortem on a decade of abandoned side projects, and what they teach us about why we keep repeating the same mistakes.
If you've built software long enough, you have your own graveyard. Half-finished apps. Domains that auto-renewed twice before you noticed. Landing pages that never got a signup form.
Going through it systematically reveals patterns. Here's what the wreckage teaches us.
The Body Count
Before we get to the lessons, the raw numbers:
That 3% isn't unusual. Most founders have similar numbers if they're honest. The difference between people who succeed and people who don't isn't the ratio. It's learning from the failures.
Cause of Death: The Autopsy
When you categorise abandoned projects by what actually killed them, patterns emerge:
Built something nobody asked for. Assumed the problem existed. Never talked to potential users before writing code.
Built for people who don't pay for software. Consumer apps. Student tools. Markets that sound big but have no money.
The MVP grew until it wasn't minimal. "Just one more feature" until the project collapsed under its own weight.
Abandoned for a newer, more exciting idea. The grass was always greener in the next repo.
Spent so long building the perfect architecture that motivation ran out before launching.
Job changes, moves, relationships. External circumstances made the project impossible to continue.
Notice what's missing: competition, funding, and technical ability. Projects don't fail because someone else is better or because founders lack skills. They fail because of choices made.
The Projects That Almost Made It
The most painful entries in the graveyard are the ones that got close. They had users. They had potential. They died anyway.
Project #14: Recipe Scaler
The idea: Automatically scale recipe ingredients based on serving size.
What happened: Built a beautiful app. Got 2,000 users. Couldn't figure out monetisation. Home cooks don't pay for software.
The lesson: B2C is brutal. Same app targeted at catering companies might have worked.
Project #19: Meeting Cost Calculator
The idea: Chrome extension showing real-time cost of meetings based on attendee salaries.
What happened: Went viral on Hacker News. 15,000 installs in a week. Then Google Calendar changed their interface and broke everything. I didn't have the energy to rebuild.
The lesson: Platform dependency is a real risk. Success can be more demanding than failure.
Project #23: Developer Portfolio Generator
The idea: Generate beautiful portfolio sites from GitHub profiles.
What happened: Got 500 paying users at $5/month. But developers kept building their own alternatives. Churn was 15% monthly. Couldn't grow faster than I was losing.
The lesson: Selling to developers is hard. They'll always think they can build it themselves.
Patterns in the Wreckage
Looking across all 31 projects, certain patterns emerge:
What the One Success Had Different
The project that survived had specific characteristics the others lacked:
The first version sold before a line of code was written. Pre-orders from real customers with real money.
Not a sexy product. Not technically interesting. But businesses pay for it every month without complaining.
One feature. One audience. One price. No scope creep. No pivots. Just refinement of what already worked.
The product lived where customers already were. No cold outreach. No paid ads. Just presence in the right ecosystem.
The Real Cost of Failure
Side projects feel low-stakes. They're not. Here's what 30 failures actually cost:
That opportunity cost number is uncomfortable to look at. Four thousand hours at $100/hour. Instead of 30 abandoned projects, that time could have gone into one project with extreme focus, with money to fund its growth.
What to Do Differently
With the benefit of hindsight:
Cleaning Out the Graveyard
Deleting old repos is cathartic. Each one represents not just failed code but failed assumptions about what should be built.
The graveyard teaches that ideas are cheap. Execution matters, but only on the right idea. And finding the right idea requires being honest about why the wrong ones failed.
Go through your own graveyard. List every abandoned project. Categorise the cause of death. Look for patterns. The failures you've already experienced are the best teachers you'll ever have.
Your next project doesn't have to end up in the graveyard. But it will, unless you learn from the ones that already did.