Skip to main content

9 min readPublished November 8, 2026Talavishiraaj Groups
Technology & Engineering

A legacy system is not an old system, it is one that costs more to work around than to change. That distinction decides the whole project, because the four available routes range from leaving it alone to replacing it entirely, and the expensive mistake is reaching for the last one when the problem only ever justified the second.

In short
  1. 01Age is not the criterion. A twenty year old system nobody needs to change is not a problem.
  2. 02There are four routes, not one: leave it, wrap it, refactor it in place, or replace it. Most projects jump to the fourth.
  3. 03Rebuilds fail more often from unrecorded dependencies than from technical difficulty.
  4. 04The knowledge of why the system behaves as it does is usually the asset at risk, not the code.
  5. 05If the business cannot run during the migration, the plan is wrong regardless of the architecture.

What makes a system legacy?

Not its age. A system is legacy when the cost of working around it exceeds the cost of changing it, and that can be true of something built three years ago and false of something built in the nineties.

The practical symptoms are consistent: changes take longer than they should and nobody can say exactly why, people have built private workarounds that the business now depends on, and the group who understand why it behaves as it does is smaller every year.

Defining it this way matters commercially, because "old" invites replacement and "expensive to change" invites a question about which part is expensive. Those lead to very different budgets.

What are the options besides replacing it?

Four, and replacement is the last. Leave it alone, which is correct more often than it is proposed: a stable system nobody needs to change is not costing you anything by existing. Wrap it, putting an interface in front so other systems can integrate without touching the inside. Refactor in place, improving the parts that actually hurt while it keeps running. Or replace it.

Most proposals arrive as the fourth option because it is the easiest to scope and the most satisfying to present. It is also the one that carries migration risk, retraining cost and a period of reduced capability, so it has to be justified rather than assumed.

The useful discipline is to make the case for each of the first three and record why it was rejected. A rebuild that survives that is a rebuild worth doing.

Why do rebuilds go wrong?

Rarely for technical reasons. They go wrong because of behaviour nobody wrote down: the edge case the old system handles quietly, the report finance depends on that was never in the specification, the field three other systems read even though it was deprecated years ago.

The second cause is duration. A rebuild long enough to outlast the attention of its sponsors becomes a project nobody can cancel and nobody can finish, running alongside the thing it was meant to replace.

The third is that the new system is specified against what the business says it does rather than what the old system actually does, and those differ more than anyone expects. What people describe and what the systems record is usually where the real requirement is hiding.

How do you find out what the system really does?

By reading the system rather than the documentation, and by watching who uses what. Logs, query patterns and integration traffic tell you which parts are live and which are decorative, which is information no interview produces reliably.

Then by talking to the people who built the workarounds. They know where the behaviour is that nobody specified, and they are usually not the people invited to the planning meeting.

This phase feels like a delay and is the cheapest insurance available. Published data puts projects that defined the requirement before committing within about 10 to 15 percent of budget, against 30 to 60 percent over for those that skipped it.

How do you keep the business running through it?

By staging it so there is never a single switch. Strangle the old system gradually: route one capability at a time to the new one, keep both answering until the new one has been right for long enough to trust, and keep the ability to route back.

That is slower and more expensive on paper than a cutover, and it is the difference between a bad week and a bad quarter when something is wrong. The cost of the parallel period is the price of being able to reverse.

If a plan cannot describe how to reverse each step, it is not a migration plan, it is a hope.

What does it cost after the project ends?

More than the build, which is the part most business cases omit. Annual maintenance commonly runs 15 to 25 percent of the original build cost, every year, and integration with surrounding systems commonly runs 35 to 50 percent of initial development on its own.

A modernization case built on the build figure alone will therefore compare a known cost against an unknown one and reach a confident wrong answer. The comparison that matters is five years of the current system against five years of the proposed one, including both.

Done that way, some modernization projects stop being obviously worth it, which is a useful thing to discover before committing rather than during year two.

When is the answer to leave it alone?

When it is stable, the change rate is near zero, and the cost of running it is predictable. Systems like that are not debt, they are infrastructure, and replacing them buys modernity rather than value.

When the thing actually causing pain is one integration or one report, which can be solved for a fraction of the cost without touching the core.

And when nobody can state what would be true after the project that is not true now. A modernization with no answer to that is being driven by discomfort with the technology rather than by a business constraint, and discomfort is a poor justification for a multi year commitment.

Where this work sits
Technology & Engineering →

We build and integrate the production systems a business runs on: internal platforms, customer facing applications, integrations, and the data layer underneath them.

Weighing a decision like this one?

Describe the situation and we will tell you how we would approach it.