Skip to content

8 Legacy Systems Examples: Why They Are Hard to Replace

Eight legacy systems examples from banking, public services, healthcare and travel, with the constraints that make each one hard to maintain or replace.

8 Legacy Systems Examples: Why They Are Hard to Replace

The popular advice says replace old software before it breaks. That's usually too late, and it's often the wrong test. A system doesn't become legacy on its birthday. It becomes legacy when a team can't change, test, secure or retire it safely, even if parts of the stack look recent.

That's the pattern across the legacy systems examples below. Each one worked for years. The constraint that made change hard sat elsewhere, in undocumented rules, scarce skills, poor data, tangled integrations, risky releases or a support deadline nobody planned around.

Survey evidence points the same way. The Ecommerce News UK report on legacy technology and technical debt found 48% of IT leaders said they could not discontinue support for legacy applications because those systems remained business-critical. Business dependence, not language alone, keeps them alive.

The eight cases that follow draw on public reports and reviews, so they can't show every internal decision. Where a control is a judgement rather than a documented finding, the text treats it that way. The useful question is consistent: what could a team have checked while there was still time to act?

1. IBM Information Management System (IMS) Hierarchical Database

IBM first developed Information Management System (IMS) in the mid-1960s for the National Aeronautics and Space Administration (NASA) Apollo programme, and it became a commercial product in 1968. It stores data in parent-child tree structures and runs high-volume transactions on IBM mainframes, usually alongside code written in COBOL or PL/I. Banks and insurers still use it as the system of record for accounts and policies, then build newer digital channels around it through application programming interfaces (APIs).

Longevity at that scale is not rare in public estates either. The US Government Accountability Office testimony on federal legacy systems notes that a 2016 review found agencies using systems with components that were, in some cases, at least 50 years old. Age alone doesn't prove danger. The risk grows when transaction codes, batch jobs and data structures embody rules that current staff have never written down.

A diagram illustrating a mainframe computer connected by an API bridge to modern digital services and applications.

Controls That Reduce IMS Risk

  • Inventory first: List every database, transaction code, batch job and downstream feed before selecting a migration path.
  • Wrap before rewriting: Put an API layer in front of proven transactions so new channels don't force changes into the core.
  • Recover the rules: Translate COBOL and PL/I decisions into plain language that product and compliance owners can approve.
  • Prove equivalence: Run old and new paths in parallel for a defined period and compare outputs before switching traffic.

The trade-off is patience. Wrapping IMS can look slow beside a rewrite announcement, but it preserves a working core while the organisation learns what that core does.

2. SABRE Airline Reservation System

American Airlines developed SABRE with IBM from the late 1950s, and it went live in 1960 as one of the first large real-time transaction systems. It handled seat inventory, bookings and fares for many agents at once, then grew into a global distribution system used by airlines, travel agents and booking websites. Web and mobile retail now sit on top, while long-lived transaction rules still run underneath.

That layered shape is common, and it creates a naming problem. Moving hosting is not the same work as changing booking logic. The UK government case study on the Welsh Government cloud migration documents a phased move between 2016 and 2019 covering hosting, email and staff smartphones, which shows how one programme can span several layers at once. Each layer needs its own acceptance measures.

A Safer Way to Modernise a Booking Core

The strangler pattern fits this kind of estate. Route one service at a time through a new component. Keep the old path available until live traffic proves the replacement, then retire it deliberately rather than leaving both paths to drift.

Fare and availability rules deserve named owners and automated tests before they move, because a correct screen can still hide a wrong price. Teams should also measure latency added by each integration layer. In a hypothetical booking flow, a few extra calls between search, pricing and payment can turn a technically successful migration into a slower customer journey.

Practical rule: Retire the old path only after the new path has carried real traffic and matched the old results.

3. VistA Electronic Health Record System (US Department of Veterans Affairs)

VistA, short for Veterans Health Information Systems and Technology Architecture, is the electronic health record used across US Department of Veterans Affairs (VA) medical centres. VA teams built it in-house from the 1980s on the MUMPS programming environment, also known as M. It covers clinical notes, orders, medication management, scheduling and billing, and its modular design let local teams add features over time.

That local flexibility helped clinicians, but it also made standardisation harder. Replacing VistA with a commercial record has faced repeated delays and reviews, which reflects the constraint. The difficult asset isn't only patient data. It's the accumulated clinical workflow, safety checks and local exceptions embedded in daily use.

Healthcare modernisation also shows why estates need portfolio thinking. An Atos case study on healthcare payer modernisation reports work across more than 50 legacy systems supporting revenue-cycle processes, with $105 million in annual application-management savings reported afterwards. Those results depend on that estate's scale and shouldn't be treated as a forecast for another operator.

A doctor transitioning from a legacy hospital computer system to modern digital patient records on a tablet.

Checks Before Clinical Migration

  • Test with clinicians: Validate safety-critical workflows with the staff who will use them under pressure.
  • Reconcile records: Map patient records, orders and medication lists, then prove counts and values match.
  • Start small: Run old and new systems in parallel at a small number of sites before wider rollout.

4. COBOL-Based State Unemployment Insurance Systems in the United States

When unemployment claims surged in 2020, several US states struggled with COBOL applications running on mainframes, and the shortage of people who could still read that code became urgent overnight. These systems pay benefits, verify eligibility and track employer contributions. State law sets the rules and changes them often, so decades of amendments sit inside code that was never designed for sudden demand at that scale.

The visible shortage was programmers. The deeper problem was that the knowledge lived in the code and in the heads of staff nearing retirement. The Ensono 2025 modernisation report found nine in ten surveyed US and UK technology and business leaders reported at least one talent gap obstructing modernisation, and a federal-agency survey reported there identified the workforce skills gap as the leading barrier, cited by 44% of respondents.

What Would Have Helped Earlier

Eligibility and payment rules should exist in plain language outside the code, with an owner for each rule and examples that tests can check. That record lets a new engineer change a benefit calculation without first reverse-engineering legislative history from comments and job schedules. It also survives turnover, which is the failure mode that hurt these states most.

Volume needs the same treatment. A surge plan should test peak claims, document uploads and call-centre status lookups before a crisis, not during one. A common response has been to put modern web intake in front of older processing, which is a sensible sequence provided the new front end doesn't create a second, conflicting record of the claim. When it does, staff end up reconciling two systems by hand at exactly the moment claim volumes are highest.

5. UK Ministry of Defence Phoenix Pay System

Phoenix was a UK Ministry of Defence (MoD) programme launched in 2013 to replace legacy pay and personnel systems with a single Oracle-based platform. Soon after launch, reported pay errors included underpayments and overpayments affecting service personnel and civilian staff. Parliamentary committees and the National Audit Office reviewed the programme and raised concerns about planning, testing and change management.

Payroll exposes weak preparation faster than most systems. A person doesn't experience a data defect as an abstract quality issue. That person receives the wrong amount of money.

Scale compounds the problem when one platform supports many connected services. A Management Consultancies Association case study on HM Revenue & Customs (HMRC) VAT modernisation describes a 50-year-old mainframe containing more than 3.1 million lines of COBOL code, supporting over 80 services and 325 data feeds. Payroll estates need the same dependency discipline, even when the code is younger.

Non-Negotiable Payroll Controls

  • Parallel pay runs: Run old and new payroll for at least one full pay cycle and reconcile every material difference.
  • Data audit first: Check accuracy, duplicates and missing values before migration, while source owners can still correct them.
  • Rollback criteria: Define the decision point, the decision owner and the evidence needed to stop before switch-over.

A payroll launch date is not evidence of readiness. Reconciled results are.

6. TSB Core Banking Platform Migration (2018)

In April 2018, TSB migrated customers from a legacy banking platform inherited from Lloyds Banking Group to a new platform built by its parent, Sabadell. Customers then faced weeks of disruption. Many couldn't access accounts, some saw other customers' information, and the bank came under intense public and regulatory scrutiny. In December 2022, the Financial Conduct Authority (FCA) and Prudential Regulation Authority (PRA) fined TSB £48.65 million, citing failures in operational resilience and migration risk management in the regulators' final notices.

Dependency made this migration hard. The accounts and data TSB needed to move lived inside a platform it was leaving, so the cutover could only be rehearsed partially before the actual switch. The control that reduces that risk is staged migration: move a small cohort first, reconcile balances and access rights against the old platform while it can still answer, and expand only when the numbers match.

Migration quality also needs objective gates. A CAST assessment of a US insurer's mainframe migration compared the pre- and post-migration system using ISO 5055-oriented structural-quality measures and reported improvement across security, reliability and maintainability. Baseline first, then repeat measurement after each tranche, gives a bank evidence rather than reassurance.

A conceptual illustration showing a person migrating bank data from a legacy core platform to a modern system.

Staging a Core Banking Move

Customers should move in phases, starting with a small cohort and measurable go or no-go criteria for each phase. End-to-end journeys need testing under production-level load before anyone moves, including the functions TSB customers lost first: account access and balance display. Rollback needs rehearsal with a named owner who can call the stop, not just a document.

Controlled staging is the approach described in these legacy system migration services, and Grail Computer Labs (GC Labs) re-platforms fragile software in controlled stages. Treat that as a method to assess against a specific scope, not as a promise about a particular bank or timeline.

7. Knight Capital Trading Software Incident (2012)

On 1 August 2012, Knight Capital Group rolled new trading software across its servers. One server missed the update, and a repurposed configuration flag woke Power Peg, a dormant test function still sitting in production code. In under an hour the firm had executed a large volume of unintended trades and lost hundreds of millions of dollars. The US Securities and Exchange Commission (SEC) later charged Knight with failing to maintain adequate controls.

The binding constraint here was invisible code, not old code. Power Peg had been left in the codebase after its original purpose ended, and the flag that triggered it had been reassigned to a new feature. Nobody owned the switch, and the release process had no check that every server ran the same build. Two controls would have cut most of the risk: deleting dead paths during each release, and an automatic halt tied to position or loss thresholds.

Release Controls That Address the Failure

  • Remove dead code: Delete unused functions and flags during each release instead of deferring cleanup.
  • Verify deployment: Check that every server runs the same build and alert when one differs.
  • Install kill switches: Set clear thresholds that stop trading or processing without waiting for a meeting.
  • Test configuration: Exercise changed flags against real production paths before go-live.

A disciplined agentic software development life cycle still rests on those basics. Automation speeds up release work; it cannot compensate for code paths nobody has mapped or switches nobody owns.

Gradual exposure adds a second layer. The Equal Experts case study on HMRC's Integration Framework migration describes moving more than 450 APIs over 15 months with weighted traffic policies and build-test-migrate checks embedded in the pipeline. Routing a small share of traffic first gives operators evidence before the whole estate depends on the change.

8. Windows XP-Based ATMs After End of Mainstream Support

Many automated teller machines (ATMs) ran Microsoft Windows XP for years because the software was stable and the hardware was built around it. Microsoft ended mainstream support in April 2014. Banks and ATM operators then had to choose between extended support, hardware and software upgrades, or accepting growing security exposure. Many bought extended support while they replaced fleets in phases.

Unsupported software becomes an operational risk when patching stops but the service can't stop. The WannaCry review covering the National Health Service (NHS) impact reports that NHS England found approximately 80 of 236 trusts were affected during the May 2017 attack, either through infection or precautionary shutdowns. The sector differs from banking, but the mechanism is familiar: unpatched platforms, incomplete inventories and indispensable workflows.

A hand-drawn illustration showing a worn-out ATM being upgraded to a modern, secure unit before vendor support ends.

Managing a Support Deadline

  • Build a live inventory: Record each device, operating system version, vendor dependency and support end date.
  • Fund the roadmap early: Set replacement dates and budget before support ends, not after the deadline arrives.
  • Isolate what remains: Place legacy devices on restricted networks while they're still in service.
  • Prioritise by exposure: Replace machines handling sensitive data, money or high-risk locations first.

Ongoing ownership matters after replacement too, which is where structured application management services can help keep versions, patches and end dates visible. The control is mundane, and that's the point. A current asset register prevents a marketing announcement from a supplier becoming an emergency programme.

How the eight legacy systems compare on sector, origin and main constraint

The first four columns show where each estate came from. The last two matter more: what fails in production, and the first safeguard that limits the damage.

ItemSectorOrigin or key dateMain constraintConcrete failure modeFirst control to put in place
IBM Information Management System (IMS) hierarchical databaseBanking, insurance, public sectorDeveloped in the mid-1960s; commercial product in 1968Scarce skills and tightly coupled hierarchical data and codeCore transactions fail; embedded rules disappearExtract rules and map data dependencies
SABRE airline reservation systemAviation and travelDevelopment began in the late 1950s; live in 1960Decades of fare and booking logic tied to older componentsWrong fares, broken bookings and queue backlogsPin golden booking journeys as tests
VistA electronic health record system (US Department of Veterans Affairs)HealthcareDeveloped in-house from the 1980sMUMPS-based architecture and local customisationsUnsafe orders, results or schedules reach care teamsFreeze a clinical workflow baseline
COBOL-based state unemployment insurance systems in the United StatesPublic services and social securityMany systems date back decades; capacity issues drew attention during the 2020 claims surgeScarce COBOL skills and limited capacity for sudden demand spikesValid claims stall or wrong benefits pay outWrite down state eligibility rules
UK Ministry of Defence Phoenix pay systemGovernment and defence payrollProgramme launched in 2013Complex pay rules and data migrationStaff are underpaid or overpaid; trust collapsesReconcile pay data against old runs
TSB core banking platform migration (2018)BankingMigration in April 2018; regulatory fines in December 2022Readiness, testing, and rollback planningCustomers lose access; regulators issue penaltiesRehearse cutover with tested rollback
Knight Capital trading software incident (2012)Financial tradingIncident on 1 August 2012Dormant code, reused configuration flags, and inconsistent deploymentA deployment fires unintended orders within minutesAudit flags, code paths and deploy parity
Windows XP-based ATMs after end of mainstream supportBanking and ATM operationsWindows XP mainstream support ended in April 2014Hardware, vendor, certification, and security-support dependenciesUnsupported ATMs remain open to known attacksSegment remaining XP machines now

The useful comparison is the safeguard, not the label. Skills shortages call for recovered rules. Data movement calls for reconciliation. Releases call for deployment parity and rollback. Support deadlines call for isolation before replacement.

Checking Your Own Legacy Systems Before They Become the Next Case

The eight examples share a pattern. The binding constraint was rarely the age of the code alone. It was an eligibility rule nobody could explain, payroll data nobody had reconciled, a dormant function nobody owned, or a support date that arrived before a funded replacement existed. Technology choices sat downstream of those facts.

The practical question for your own estate is which of those constraints you carry. A useful first audit is small enough to finish. Pick one critical workflow and write down the rules it enforces, who owns each rule, the data it trusts, the systems it touches, and the evidence that would prove new behaviour matches the old. Then test whether the team can make one low-risk change, release it, observe it and roll it back. If that loop fails, the organisation doesn't yet have a migration problem. It has a controlled change problem, and fixing that loop comes first.

Cost pressure explains how estates drift into that state. The SnapLogic and Censuswide research release found that in 2024, 65% of businesses surveyed reported investing more than US$2 million in maintaining or upgrading legacy systems. Spending at that level can still leave knowledge undocumented when the money goes only to keeping services running. Funding rule recovery, test coverage and release safety as named outcomes works better than treating them as spare time between incidents.

Modernisation also takes more than one shape. The Government Accountability Office report on successful federal modernisation initiatives found 94 successful legacy-system modernisation initiatives completed by 24 major agencies during the five years covered by its review, spanning code translation, cloud moves and architectural redesign. The right pattern depends on whether the foundation is sound, whether production data and business logic are trustworthy, and whether failures sit in identifiable parts of the estate. Teams weighing that choice can look at how to future-proof your legacy applications while keeping the immediate decision concrete: improve the current platform when its architecture can support the next stage and a reliable release process can be restored quickly; rebuild in controlled stages when it can't, keeping useful data, business rules and operating knowledge rather than discarding them with the old code.

Grail Computer Labs audits inherited platforms across code, data, infrastructure and product documents before rebuilding, then proves the new behaviour before release. Qualified clients can start with an outcome engagement under a 15-day trial and stop within the first 15 days without paying.


To discuss a system your team can no longer change safely, visit Grail Computer Labs.

Software Risk Analysis for Delivery Leaders

Software risk analysis that scores likelihood and impact across delivery, security, operations and vendors, then turns the register into a decision.

13 min read