Blog / Operating systems & apps /

Legacy software: why companies keep old systems

When an airline’s check-in goes down, or a bank’s app is “temporarily unavailable” for a day, the comments pile up: why are they still running software from the last century? Just replace it.

My argument is that keeping old software is, in most cases, not laziness. It’s a bet that the known risk of the old system is smaller than the unknown risk of a replacement. Sometimes that bet is right. Sometimes it’s a slow trap. The skill is telling which one you’re in.

What “legacy” actually means

Legacy software is any system that still does an important job but is built on older technology, often something the original creators have long left behind. It isn’t automatically bad. Age alone doesn’t make software wrong; it makes it harder to change.

Typical examples: accounting systems written decades ago, booking engines in transport and hospitality, a stock system in a warehouse, or an internal tool that one person built years ago and everyone uses. Plenty of banking and government processing still runs on code that is many decades old. That tells you something: if it were easy and cheap to replace, they’d have done it.

Reason 1: it works, and “it works” is worth a lot

A system that has run every working day for twenty years has been tested by reality in a way no new software can match. Every odd case, strange customer and awkward date has already happened to it, and the system was patched to cope.

A replacement has to rediscover all of that. The old software contains years of business rules, written not in a document but in code. Often nobody can list them all. Switch it off, and you lose rules you didn’t know existed.

Reason 2: replacing it is a big, risky project

Rewrites have a bad reputation, and for good reason. They take longer than planned, cost more, and often deliver less than the old system did on day one. Meanwhile the business can’t stand still: the old system still needs fixing, and the new one is a moving target.

The danger is the “big bang” switch-over: one weekend, everything changes. If anything goes wrong, the whole company feels it on Monday. Faced with that, many managers decide the cost of staying is lower than the risk of going.

Reason 3: everything else depends on it

Old systems rarely stand alone. Over the years, other systems have been wired into them: reports, payment gateways, partner feeds, spreadsheets that pull data at midnight. Replacing the core means finding, rebuilding and testing every connection, including the ones no one remembers.

It’s like trying to move a load-bearing wall. You can do it, but you have to know exactly what is sitting on top.

Reason 4: the money is in running the business, not the software

For most companies, software is a means to an end. A manufacturer makes money from manufacturing. Spending a large sum to replace a system that already does the job means taking money away from things customers see.

That logic holds until the old system starts to block growth, such as the day the company wants to sell online, integrate with a new partner or support a mobile app, and the old system can’t.

Reason 5: regulation, validation and trust

In some industries, software must be validated, audited or approved. Healthcare, finance, aviation and public services have strict rules. Changing the system might mean repeating long compliance processes. In those cases, “don’t touch it” is a policy, not a mood.

Reason 6: the people and the knowledge

Some systems survive because a few people understand them. Others become frightening because nobody does. Both are a problem. The first creates dependence, the second creates a mystery. Documentation helps, but it’s rarely as good as it should be.

The strongest argument against me

The counter-argument is serious: legacy systems carry real costs.

  • Security. Old software may no longer receive security fixes, and older platforms are easier to attack. Windows 10 reaching the end of support is a familiar example of how a platform deadline can turn “stable” into “risky” (Windows 10 end of support: what to do before October 2025).
  • Skills. Fewer people know old languages and tools, so hiring and maintaining gets harder and more expensive.
  • Speed. Every new feature takes longer, because each change risks breaking something.
  • Compatibility. Modern browsers, devices and integrations may not work with the old system.
  • Hidden failure. The older the system, the more a single failure can take down everything, as outages like the CrowdStrike incident show about how interconnected systems fail.

I accept all of that. My answer is that these costs are real, but they don’t automatically justify a rewrite. They justify a plan.

What a sensible plan looks like

The healthiest companies don’t choose between “never change” and “replace everything”. They do something in between:

  1. Map what the system does and what depends on it. You can’t replace what you haven’t described.
  2. Protect it. Back up, monitor and keep it isolated from the open internet where possible.
  3. Wrap it. Put a modern layer in front of the old one so new apps and sites can talk to it without touching the core.
  4. Replace it in slices. Move one function at a time, running old and new in parallel until the new one proves itself.
  5. Document as you go. Every rule you rediscover should be written down.
  6. Set a decision point. A date or trigger (end of support, a cost threshold) at which the plan changes.

Why this matters if you run websites

Most of us run legacy software without noticing. That old WordPress theme nobody dares update, the plugin that hasn’t had a release in years, a custom script on the server, an old PHP version that “works fine”. The reasoning is the same as in a big company: it works, and changing it feels risky.

The lessons carry over:

  • Know what depends on it before you touch it.
  • Back it up and test restores. Backups for websites: what to keep and where helps.
  • Update in small steps, not in one leap.
  • Keep a list of the things you’re postponing, and review it.

And the opposite lesson matters too: “if it ain’t broke, don’t fix it” stops being true the moment security patches stop. Quietly postponed upgrades have a habit of becoming emergencies.

Key takeaways

  • Legacy systems survive because they work, because replacing them is risky, and because so much depends on them.
  • The costs are real: security, skills, speed and compatibility.
  • The answer is usually a plan (map, protect, wrap, replace in slices), not a heroic rewrite.
  • The same logic applies to the old plugin or script on your own site.

Think about the oldest piece of software you rely on, at work or at home. Would you replace it tomorrow, and what would you need to know first?