Skip to content
ADVIQ LABS
All insights

Engineering3 min read

Modernising a legacy system without a big-bang rewrite

Full rewrites are tempting and risky. The strangler pattern lets you replace an old system piece by piece while the business keeps running. Here's how it works in practice.

ALBy the Adviqlabs team

Every growing company eventually owns a system that runs the business and scares the team. It's slow to change, few people understand it, and every deploy feels like a gamble. The instinct is to rewrite it from scratch.

Full rewrites fail more often than they succeed. They take longer than planned, the old system keeps changing underneath them, and for months the business gets nothing new. There is a calmer way.

The strangler pattern in one paragraph

Instead of replacing the whole system at once, you put a layer in front of it, then move functionality to a new system one piece at a time. Each piece goes live as soon as it's ready. Over time the new system grows around the old one until the old one can be switched off. The name comes from strangler fig trees, which grow around a host tree and eventually replace it.

Step 1: Understand what you actually have

Before planning anything, map the system:

  • Workflows: what do people actually do with it every day? Talk to the users, not just the code.
  • Data: which tables matter, what's duplicated, what's dead
  • Integrations: every file drop, cron job, webhook and "that spreadsheet finance imports on Mondays"
  • Pain: where are the bugs, slow pages and risky deploys concentrated?

This audit usually takes one to three weeks and pays for itself many times over. Most modernisation surprises are integrations nobody wrote down.

Step 2: Put a front door in place

Add a routing layer between users and the system: a reverse proxy, an API gateway, or a new frontend that calls the old backend. At first it passes everything through unchanged. This is the seam that lets you redirect one route, page or API call at a time to new code.

Step 3: Pick the first slice carefully

A good first slice is:

  • Valuable: it removes real pain, so the business sees progress early
  • Contained: few dependencies on the rest of the system
  • Reversible: you can route traffic back to the old version if needed

Reporting screens, a customer-facing portal or a single workflow are common first slices. Billing and core transaction logic are usually not.

Step 4: Handle the data honestly

Data is where modernisation projects get hard. The common approaches:

  • Shared database first: the new code reads and writes the old database. Fastest to start, but you inherit the old schema's problems for a while.
  • Sync in one direction: the new system owns its own tables and receives changes from the old one through events or scheduled syncs.
  • Migrate per slice: each slice brings its data across when it goes live, with validation scripts that compare counts and totals.

Whichever you choose, write verification checks. "The numbers match" should be a script, not a feeling.

Step 5: Run old and new side by side

For risky slices, run both versions in parallel for a while. Compare outputs, or send a small percentage of traffic to the new path behind a feature flag. When the results match and the team is confident, switch fully and keep the old path available for a quick rollback.

Step 6: Repeat, then retire

Each slice follows the same rhythm: audit, build, verify, switch, clean up. Once nothing routes to the old system, archive its data, turn it off and celebrate. Don't skip the clean-up. Half-retired systems keep costing money and attention.

Signs you need modernisation, not just maintenance

  • Simple changes take weeks because nobody is sure what they'll break
  • The system depends on a runtime or framework version that no longer gets security updates
  • Only one or two people can deploy it
  • Hiring is hard because the stack is unfamiliar to most developers
  • Performance problems are architectural, not just a slow query

What to expect

A step-by-step modernisation takes longer to finish than a rewrite looks like it will on paper. But it delivers value from the first slice, keeps risk small at every step, and never leaves the business waiting a year for a "big switch-over weekend".


Living with a system like this? We start every modernisation with an audit and an incremental plan. Tell us about it.

Start a project

Have a product in mind? Let's scope it together.

Book a free call. We'll talk through your idea, suggest the leanest path to launch and follow up with a written proposal.