Should we just rewrite it?

Almost never. A full rewrite means two systems to maintain, a feature freeze nobody honours, and a delivery date that moves. Incremental extraction is slower on paper and finishes considerably more often.

There are no tests. How do you change anything safely?

Characterisation tests first — capture what the system currently does, including behaviour that is arguably wrong but that something downstream depends on. Those tests are the safety net that makes the rest possible, and building them is genuinely the first deliverable.

Nobody understands the system. Can you work with that?

It is the normal starting point. We reconstruct behaviour from the code, the database, production traffic and whoever is still around, and we document as we go. The documentation is a deliverable, not a side effect.

What gets extracted first?

Something with a clear boundary, real business value, and low coupling — often reporting, notifications or a specific integration. The first extraction proves the pattern and builds the scaffolding the rest reuses.

By use case

Legacy Modernisation

Change the engine without stopping the car

Scope this for us Model the savings

Usually owned by

Engineering
CTO office
Operations

18 mo
Typical programme, value each quarter: 0
Big-bang rewrites we recommend: 10x
Release frequency on modernised paths

The change

What actually differs afterwards

Not a maturity model. The concrete difference in how the work happens.

Today

One monolith nobody wants to deploy
The only person who understands it is close to retirement
Releases quarterly, and each one is an event
No test coverage, so no safe way to change anything
Vendor support ending on a component you depend on

Afterwards

Highest-risk capabilities extracted and independently deployable
Behaviour captured in tests before anything is rewritten
Weekly releases for the modernised paths
Legacy core wrapped in a documented API layer
A sequenced plan with value arriving each quarter

Why big-bang rewrites fail

The plan is eighteen months. At month fourteen the new system does 70% of what the old one does, the business has kept asking for changes to the old one, and both are now being maintained by a team that has stopped enjoying its job.

This is not a failure of skill. It is arithmetic: a system that has accumulated fifteen years of edge cases encodes more requirements than anyone can enumerate up front.

Strangling instead

Rewrite

Freeze features and rebuild everything
One cutover date for the whole system
Value arrives at the end, if it arrives
Requirements gathered from documentation

Incremental extraction

Extract one capability at a time behind a facade
A sequence of small, reversible cutovers
Value arrives every quarter
Behaviour captured from the running system and its tests

Traffic for one capability is routed to the new implementation behind a facade. The old path stays available until the new one is proven. Repeat. The legacy core shrinks until what remains is small enough to either replace or leave alone deliberately.

The first deliverable is tests

Before extracting anything, we capture what the system currently does — characterisation tests, written against actual behaviour rather than intended behaviour. This routinely documents bugs that downstream systems have come to depend on, which is exactly the class of surprise that derails rewrites.

Sequencing by risk

The order is driven by risk and coupling, not by what is most interesting to build. Anything with an end-of-support date or a single point of human knowledge goes first, because those are the items where the cost of waiting is real and rising.

FAQ

Questions we get asked

Let's find out what is actually automatable

Bring a process that annoys you. In 30 minutes we will tell you whether AI helps, what it would cost, and where it would fail — even if the answer is don't bother.

Book a consultation Get a quote

Or email [email protected] · we reply within 1 business day