The starting point
Characterisation tests are the permission slip for touching old code
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
Before we change a line of an application we do not fully understand, we pin down what it currently does. Characterisation tests feed the existing code real inputs and record its actual outputs — not what the specification says it should do, but what it does, including the oddities. Those tests become the contract for the migration: every route that moves to the new system must produce the same answers the old one did, and any deliberate difference is a decision someone made, not an accident someone finds later.
This is unglamorous work and it is the highest-value hour of the engagement. Modernisations that fail rarely fail on the new technology; they fail on the behaviour nobody knew was there — the rounding rule from a decade ago that a downstream report depends on. Capturing that behaviour before the migration is the difference between an engineering programme and an archaeology dig conducted in production.
The method
Strangling an application in five deliberate moves
The strangler pattern grows the new system around the old one until nothing routes to the old code. Each move is small, tested and reversible.
Pin the behaviour
Characterisation tests capture what the application actually does on its important paths, oddities included. A safety net that turns unknown code into described code.
Put a front door on it
A routing layer goes in front of the old application, initially passing everything straight through — invisible to users, decisive for what follows. A single point where traffic can be steered, route by route.
Move the first route
One capability — chosen for value and low entanglement — is rebuilt and takes its traffic through the front door, checked against the pinned behaviour. Proof the method works on your application, not in a slide.
Decouple the data
Shared tables are the hidden coupling. Each moved capability gets ownership of its data, with synchronisation while both sides live, so the database stops being the place where old and new secretly meet. Data whose owner is knowable, per capability.
Repeat until the old code is idle
Routes move in order of value and risk. The old application is retired when its traffic reaches zero — an observation, not a ceremony. A modern application that took over without a cutover night.
Illustrative engagement
What a year of modernising a working application can look like
Typical engagement — illustrative, not a named client
A billing application a decade old, in daily use, original developers gone, its database shared with a reporting tool and two exports nobody dares touch. The board wants it modern; operations wants it untouched.
- 01The first weeks produce no new features: characterisation tests around invoicing and the two exports, and a routing layer in front of the application that changes nothing visible.
- 02Invoice generation moves first — high value, moderately entangled — and runs the new code against the old answers until they agree for a full billing cycle before the route flips.
- 03The reporting tool is pointed at a read model fed by the new system, which unhooks the shared database quietly; remaining routes then move in descending order of pain, each with a way back.
The operation never stopped, and the risky moments were rehearsed rather than survived. The pace is set by how much change the business absorbs per cycle — which is the honest constraint, not the technology.
Our role
Where we stand on the rewrite question, case by case
- 01
An honest assessment first
We map the application's seams, coupling and test coverage before recommending a route. Sometimes the answer is that a rewrite genuinely is cheaper — a small system, well understood, whose behaviour can be verified — and we say so.
- 02
The migration, run in slices
We build the routing layer, write the characterisation tests, and move capabilities one at a time — with the old application as the reference until the new one has earned each route.
- 03
Your developers inside the work
The people who will maintain the modern application help build it. A modernisation delivered as a sealed box recreates the original problem with newer syntax.
How much change the business can absorb per quarter is your call; we shape the slices to fit it, and every step keeps a way back until the new code has earned its traffic.
Common questions
What buyers ask
What are characterisation tests and why write them before changing our application?+
They are tests that record what the application currently does — real inputs in, actual outputs captured — rather than what anyone thinks it should do. For an old application, its behaviour is the only complete specification that exists, and some of that behaviour is load-bearing in ways no document mentions. Written before any change, these tests turn the migration from "we hope nothing broke" into "the new code produces the same answers, and here is the proof". When a difference is intentional — an old defect finally fixed — it becomes a recorded decision instead of a production surprise.
Our application and its database are tangled together. Where does decoupling start?+
With reads, and with one capability. The shared database is usually the real legacy system — the application is just its most visible client — so we never try to split it in one operation. The first moved capability gets its own data store, kept in step with the old tables while both sides are live; reporting and exports get pointed at read models fed by the new system, which removes the most common reason the old schema cannot change. Table by table, ownership moves with the capabilities, until the shared database is no longer where old and new secretly depend on each other.
Is a full rewrite ever genuinely cheaper than modernising in place?+
Yes, in a narrow set of cases, and pretending otherwise would be dishonest. A rewrite wins when the application is small, its behaviour is genuinely well understood or easily verified, the strangler machinery — routing layer, parallel running, data synchronisation — would cost more than the code it protects, or the platform underneath is being retired outright. It loses, usually badly, when the application is large, entangled and only partly understood, because the rewrite must reproduce years of unwritten behaviour and then prove itself in one cutover. Our assessment puts numbers and named risks against both routes for your specific application, rather than applying a doctrine.
In this cluster
Next step
Plan it with us
A modernisation assessment that maps the application's seams, names the first route to move, and gives an honest rewrite-versus-strangle recommendation.
Plan it with us
What happens next
- 1We reply within one business day.
- 2A 30-minute scoping call with a senior consultant.
- 3A written proposal with scope, team, and timeline.
Or reach us directly

