The system still runs your business, and nothing new can connect to it. We move it onto something maintainable one piece at a time, proving at every step that its behavior hasn’t changed.
Somewhere in your organization there is a system everyone works around. The person who understood it has left, the vendor no longer answers, and the rules that keep your invoices correct exist only in its code. Lately it has also become the reason a new integration, an automation or an AI project can’t start, because nothing can reach its data. A full rewrite sounds clean until you price running both systems and freezing development in the meantime.
Why it can no longer wait
Old systems are rarely replaced because they are old. The trigger is usually something new the business wants to do, and the system is what stands in the way.
A new system has to connect
A web shop, partner portal or new CRM needs orders and customers from the old system, and the only way in is a nightly file or a database nobody dares query.
A workflow should run without re-keying
An approval or back-office step could be automated, but the system has no interface an automation or agent can call, so a person copies values between screens.
AI needs its history
Years of transactions sit in tables nobody can explain. A forecasting model or an agent needs that history readable and documented before it is of any use.
Support is ending
The runtime or database is approaching the end of its security updates, and a vendor’s notice has set a date the business didn’t choose.
Two ways through
The real choice is when you take the risk
Big-bang rewrite
Build the full replacement alongside the old system, then switch over on a set date. It is clear about the end goal and easy to fund as one project.
A clean design, free of the old system’s limitations
One budget, one plan, one date the board understands
The old system is frozen while the new one catches up
Nothing is proven until the one day when everything matters
Incremental replacement
A stable interface goes in front of the old system, and its functions move behind it one at a time, with both versions live until the new one is trusted.
Each part reaches production and can be rolled back on its own
The business keeps releasing while the migration runs
Behavior is compared with the old system before anything is retired
Longer on paper, and the interface itself takes real effort
Four routes, plus the option to do nothing
Modernization is decided per capability, not for the whole system. A system is rarely uniform: the pricing engine may be worth rebuilding while the batch job that posts to the ledger should be left exactly as it is. So the route is chosen separately for each capability, and one program usually runs two or three routes at once.
Some systems should be left alone, and it helps to know what that looks like. The system is stable, almost never needs changes, runs on a platform that still receives security updates, and costs a license fee rather than a backlog of blocked work. If something new only needs to reach it, an interface in front may be the whole job. A system like that is a paid-off asset, not technical debt.
The four routes
What each route is for
Encapsulate, re-host, re-architect, rebuild. The choice is mostly economics: how often the capability changes, how well anyone understands its behavior, and what the business loses for every hour it is unavailable.
Encapsulate
Wrap it in an API and leave it
The system stays where it is, and a documented interface goes in front of it, so new systems, automations and agents connect to the interface rather than its internals. Right when the code is stable but nothing can reach it. You gain integration and time, not maintainability.
Re-host
Move it with as few changes as possible
The same code on a supported runtime, a current database version and infrastructure that is still sold. The cheapest route with the clearest end date, but the code itself doesn’t improve. It fits when the deadline comes from an end-of-support notice, not a business need.
Re-architect
Replace it module by module
New code takes over one capability at a time behind a routing layer, with the old version live until the new one proves itself. The most effort of the four, and the only route that keeps delivering to users throughout. It needs a clear boundary where a router can sit.
Rebuild
Write the capability again
Sometimes the old behavior is the problem. When a capability no longer matches how the business works, copying it exactly is wasted effort, and it should be redefined from scratch. This route waits longest before anything goes live, so it suits one bounded capability, not a whole system.
How one capability moves
Whatever the route, each capability follows the same order, and the old version keeps running until the evidence says it can stop. Read-only capabilities usually go first, because they carry the least risk if traffic has to be switched back.
01
Read the system
We learn how it behaves from the system itself: the data it produces, the requests it handles, and which parts of the code are still in use. You receive a written account of what it does, including rules nobody had documented.
02
Pin the behavior down
Before anything changes, current behavior is captured in tests, odd results included, because some of those oddities are rules the business depends on. You review the test cases with the people who notice first when something goes wrong.
03
Add an interface
A documented API or routing layer goes in front of the old system, so callers stop depending on its internals. New systems can connect at this point, before any code has moved, and you can see the interface contract.
04
Move and compare
One capability moves behind the interface while the old version keeps running, and the two are compared on real requests. You see the comparison report, and switching back is a routing change, not a recovery project.
05
Retire the old path
When the comparison stops finding differences, the old code path is switched off and removed. Runbooks and the decision record ship with each capability, in your repositories, so your team can run what has moved.
The questions that come first
Mostly, yes. The incremental route exists because few businesses can freeze development long enough to rewrite a working system. New features are built in whichever version currently owns that capability, which means some work is duplicated during the overlap. That cost is real, and we would rather state it than pretend the overlap is free.
Not sure which one you need?
Describe the problem in a paragraph and we will tell you which service applies.