- Market
- Saudi Arabia
- Written for
- CIO, CTO
- Decision
- Modernise a system the business still depends on
- Languages
- EN · AR
The method
Replacing an engine that cannot be switched off
Not a rewrite and a switchover, but a slice moved at a time with the old system still carrying everything else. The rollback branch is what makes each step reversible.
A flow: characterise behaviour, wrap the old system, move one slice, retire the old slice — with a rollback for each slice until the new one has earned the traffic.
- 01
Characterise what it does
Capture the real behaviour, including the undocumented rules the business quietly depends on, before changing a line.
- 02
Wrap, do not gut
Put a boundary around the old system so new work can be built beside it rather than inside it.
- 03
Move one slice
Redirect one capability to the new system, with the old one still able to take it back.
- 04
Retire the old slice
Only once the new one has carried real traffic long enough to trust, then repeat for the next.
Roll the slice back
Every slice keeps a path back to the old system until the new one has earned the traffic. A modernisation you cannot reverse mid-step is a big-bang rewrite wearing an incremental costume.
Why the big rewrite fails
The rules nobody wrote down
The reason a from-scratch rewrite so often fails is not the new technology; it is that the old system encodes years of exceptions, edge cases and quiet business rules that no document describes and no current employee fully remembers. A rewrite that starts from the specification rebuilds the system that was specified, not the one that runs — and the gap between them is discovered in production, as broken invoices and stuck orders.
So the honest method is incremental and evidence-led: characterise the real behaviour first, keep the old system running as the reference, and move one slice at a time with a way back. It is slower to start and far safer to finish, because the business never bets its operation on a single switchover that has to be right the first time.
What makes it safe
The conditions a live replacement depends on
These are what let the old and new run together without the business feeling the seam.
Behaviour captured before change
The undocumented rules are the ones a rewrite loses, so they are recorded as tests before anything moves.
What it protects: The edge cases the business quietly relies on.
The old system as reference
It keeps running so a new slice can be checked against what it actually produced, not against a spec.
What it protects: A new slice proven against reality before it is trusted.
A rollback per slice
Each step keeps a path back until the new slice has carried real traffic long enough.
What it protects: An operation that never bets on a single irreversible switch.
A slice small enough to reason about
Moving a bounded capability at a time keeps the blast radius of any mistake small.
What it protects: A failure that affects one capability, not the whole system.
Our role
What we carry and what stays with your operation
- 01
Evidence before architecture
We characterise what the system actually does — including the rules nobody wrote down — before proposing a target, because a target chosen without that is a guess.
- 02
One slice at a time
We move capabilities incrementally with the old system as the reference and a rollback for each, so the business never carries the risk of a single big switchover.
- 03
Your team on the inside
Your people know the exceptions we need to preserve; we work with them rather than around them, and leave a system they understand rather than a new black box.
The order the business can tolerate change in, and the risk it will accept per slice, are yours to set; we make each step reversible and evidence-led, so modernisation never costs an outage the operation cannot afford.
Common questions
What buyers ask
Should we rewrite from scratch or modernise incrementally?+
For a system the business runs on, almost always incrementally. A from-scratch rewrite has to reproduce years of undocumented behaviour perfectly and cut over in one risky step, and it usually discovers what it missed in production. Moving one slice at a time, with the old system as the reference and a rollback for each step, is slower to start and dramatically safer to finish. A full rewrite makes sense only for a small system whose behaviour is genuinely well understood — which is rarely the one that hurts enough to modernise.
The people who built it have left. Can it still be modernised?+
Yes, and it is the usual situation. When the original authors have gone, the system itself becomes the only reliable specification, which is exactly why we characterise its real behaviour first — capturing what it does as tests, including the exceptions no document mentions. Your current team, who operate it daily, hold more of that knowledge than they think, and we work with them to surface it. What we do not do is start from a specification that describes the system someone intended rather than the one that runs.
How do you keep the business running during the change?+
By never switching the whole system at once. The old system keeps carrying everything except the one slice being moved, and that slice keeps a path back until the new version has handled real traffic long enough to trust. The business feels the change as a series of small, reversible improvements rather than a single high-stakes cutover night. The trade is that the two systems run in parallel for a while, which is a manageable cost next to the alternative of betting the operation on one switchover.
In this cluster
Next step
Scope it with us
A modernisation plan that names the first slice to move, how the old and new run together, and the rollback for the cutover — before any code is rewritten.
Scope 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

