Skip to content

Modernise or Rebuild? How I’d Decide

When an old system is causing you pain, the default should be to modernise it in place, not rebuild it — and you only flip to rebuild when the foundations themselves are the problem, not the surface. Most people reach for rebuild far too quickly, because the old system is ugly and the new one is imagined, and imagined systems have no bugs yet. That asymmetry is a trap, and it’s expensive.

That’s the answer. Here’s why rebuild is the call people get wrong in the costly direction, the specific conditions that genuinely justify it, and how to tell the difference.

Why rebuild is the seductive wrong answer

Every developer who looks at an old codebase wants to rebuild it. This is close to a law of nature. The old system is messy, full of decisions that no longer make sense, hard to change, and the work of understanding it is tedious. A rebuild promises a clean slate, modern tools, and none of the accumulated cruft. It’s genuinely appealing, and it’s usually wrong.

The reason it’s wrong is that the old system, for all its ugliness, works. It encodes years of hard-won knowledge — every weird edge case it handles is a real problem someone hit, every strange bit of logic is a business rule somebody needed. That knowledge is invisible. You don’t see it in the code; you only discover it when the rebuild ships without it and something breaks that used to work. A rebuild starts from zero and has to rediscover, the hard way, everything the old system already knew. People consistently underestimate how much that is — it’s most of the actual value, and it’s exactly the part that doesn’t show.

So a rebuild typically takes far longer than anyone predicts, ships missing things the old system handled silently, and spends its first year re-fixing bugs that were fixed years ago. Meanwhile the old system, which still runs the business, gets no attention because everyone’s building its replacement. That’s the trap: you stop maintaining the thing that works to build a thing that isn’t ready, and you live in the gap for longer than you can afford.

Modernising in place is usually the real answer

Most “we need to rebuild” situations are actually “we need to modernise,” and modernising is a different, safer, cheaper thing. You keep the system running and improve it piece by piece, replacing parts rather than the whole, so the business never falls into the gap.

The pain people attribute to “the whole thing is old” is usually concentrated. It’s one ancient module, one bad integration, one part of the data model that’s fighting everything else, one layer that’s slow. You don’t need to rebuild the system to fix that — you need to find the specific source of the pain and replace that, while everything around it keeps working. Modern code can live alongside old code; you carve out the worst part, rebuild just that piece behind the same interface, and the rest of the system doesn’t notice. Do that a few times, to the parts that actually hurt, and you’ve modernised the system without ever taking the risk of replacing all of it at once.

This is the same instinct as MVP-first, pointed at an existing system. Don’t do the big all-or-nothing thing. Do the smallest change that removes the actual pain, ship it, and compound. The system stays alive and owned the whole time, and you never bet the business on a rewrite landing.

When rebuild is genuinely the right call

I’m not against rebuilding, and there’s a real line where it becomes correct. The test is whether the foundations are the problem, not the surface.

Rebuild when the core architecture makes the changes you need impossible, not just hard. If the system is built on an assumption that’s now false — single-tenant when you need multi-tenant, built for hundreds when you need millions, structured around a model of the business that no longer matches the business — and that assumption is baked into the foundations, then modernising means fighting the foundation on every change. At some point the cost of working against the architecture exceeds the cost of replacing it, and that’s the line.

Rebuild when the technology underneath is genuinely dead — unsupported, unhireable, a security liability with no patches coming. Not “old,” dead. There’s a real difference between a mature system in a stable older technology and one sitting on a platform nobody maintains and nobody under forty will touch.

Rebuild when you’ve modernised the painful parts honestly and the system still fights you everywhere, because the problem was never localised — it was the whole structure. If piece-by-piece improvement keeps hitting the same architectural wall no matter which piece you touch, the wall is the problem, and the wall is the foundation.

The common thread: rebuild when the problem is structural and load-bearing, not when the system is merely ugly or old. Ugly and old are modernise problems. Structurally wrong is a rebuild problem.

The question almost nobody asks

Before either call, the question is what the system actually needs to do now — not what it does, not what it did when it was built. Old systems accumulate features nobody uses and shapes nobody needs any more. People scope a rebuild to recreate everything the old system does, which is how rebuilds balloon — they’re rebuilding capabilities the business outgrew years ago.

If you’re rebuilding, you’re not recreating the old system; you’re building the system the business needs today, which is often dramatically smaller. Half of what the old system does may be dead weight you can simply drop. Scope the rebuild to the real, current problem — the same ruthless cut as scoping an MVP — and a terrifying rebuild becomes a manageable one. The thing that makes rebuilds fail is treating them as a faithful reconstruction instead of a fresh, lean solve of the actual current need.

A pattern I see

The recurring one: a business with a system that’s served them for years, now slow and awkward to change, and a developer or agency telling them it’s time to rebuild from scratch. The quote is large, the timeline optimistic, and the founder is told the old system is beyond saving. They’re about to commit a year and a fortune to a rewrite.

When I look, the system isn’t beyond saving at all. It’s a fundamentally sound structure with two or three genuinely painful parts — one slow module, one tangled integration — and modernising those specific parts would remove most of the pain for a fraction of the cost and risk, with the business never going dark. The rebuild was the appealing answer, not the correct one — and not infrequently the appeal was partly that a rebuild is a bigger, more profitable piece of work for whoever’s recommending it. The honest call was to fix the three things that hurt and leave the rest alone.

Who this isn’t for

If your system is a small, simple thing and rebuilding it lean would genuinely take a couple of weeks, don’t agonise over this — just rebuild it cleanly and move on, the careful modernise-vs-rebuild analysis is for systems big enough that the wrong call costs real money. This playbook is for the substantial systems where rebuilding is a serious bet.

The call, in one line

Modernise the parts that hurt and keep the system running — and only rebuild when the foundations themselves, not the surface, are what’s holding you back.

This is one of my playbooks. It runs on the same logic as build or buy? — own and improve the system rather than make a big all-or-nothing bet — and connects to how to rescue a stalled build, since a botched rebuild is one of the most common ways a build stalls. To understand the accumulated cost that drives these decisions, what technical debt actually costs is the next read.

If you’ve been told your system needs a full rebuild and want an honest second opinion on whether it really does, talk to me — that one conversation has talked more than a few people out of a year-long mistake. And if the honest answer is a genuine rebuild that needs a team to deliver and run, that’s what my agency, Digital Royalty, is for.