Every ageing system eventually produces the same meeting: the one where someone says “let’s just rewrite it.” It feels clean. It’s usually a trap. Full rewrites routinely take twice as long as planned, freeze feature delivery for the duration, and launch with regressions the old system solved years ago — because the old system’s bug fixes were the specification.

Why rewrites fail

  • The old system doesn’t stand still. While you rebuild, the business keeps demanding changes — now you maintain two systems.
  • Hidden knowledge. Twenty years of edge cases live in that code. A rewrite discards them and rediscovers each one in production.
  • The big-bang cutover. One migration weekend where everything must work. It rarely does.

The strangler approach: replace by slices

The pattern we use is the strangler fig: grow the new system around the old one, routing one capability at a time to the new code until the legacy core has nothing left to do. Every slice ships value, and there is no cliff-edge cutover.

  1. Put a facade in front. An API layer or gateway through which all traffic flows — this is the switchboard that lets you move capabilities gradually.
  2. Pick the first slice — high pain, low entanglement. Reporting and read-only views are classic first candidates.
  3. Sync the data, then own it. New modules start by mirroring legacy data, and take over as the source of truth only when proven.
  4. Retire loudly. Each time a legacy module goes dark, measure and announce it. Momentum is a deliverable.

Modernization is a series of small victories, not one big battle.

From our work

On enterprise modernizations we scope each slice to land within a quarter. The business sees progress every few weeks, and if priorities shift, the programme can pause at a stable point — something a half-finished rewrite can never do.

When a rewrite is actually right

Honesty matters: if the system is small, the domain is simple, and the technology is truly dead (no runtime, no hires, no vendor), a contained rewrite can be cheaper than scaffolding around it. The test is size and blast radius — rewrite a module, strangle a platform.

The takeaway

Legacy systems are assets with bad interfaces, not liabilities to be dynamited. Modernize them the way they were built — incrementally — and your transformation ships value every quarter instead of promising it all at the end.