Service · Software development

Modernising legacy software with strategy and execution.

Business-critical applications that are too old to extend easily, but too important to simply replace. We guide the entire migration: from portfolio analysis and 6R classification to strangler fig rollout and handover to maintenance.

6R strategyStrangler figCloud migrationKnowledge transfer

Legacy is not the same as technical debt.

Technical debt is incremental mess: a refactor here and there, adding test coverage, upgrading dependencies. A legacy modernisation is an order of magnitude bigger. It concerns systems where the tech stack itself is the problem: a Delphi application whose original developer left years ago, an AS/400 with RPG code that nobody dares touch any more, a Classic ASP portal that no longer works with modern single sign-on, or an Oracle Forms environment that only runs on a specific version of Java that has itself reached end-of-life.

The pain is familiar: every change is expensive, every extension feels risky, and the people who still truly know the system are becoming ever scarcer. At the same time, there are often years of carefully built-up business logic inside. That must not be lost in a migration, but the stack it runs on deserves a second life elsewhere.

We have been doing this work since companies were planning their first cloud migrations. We are pragmatic: not every legacy app needs to be rebuilt, some simply need to be retired, and others can run perfectly well for years after a rehost. The art is making the right choice for each application, and planning the migration so the business doesn't notice. For incremental clean-up work within a single codebase, we'd refer you to our page on resolving technical debt; for the hosting side, we recommend our page on carrying out a platform migration.

Two things belong with a modernisation that are often only picked up afterwards, when they cost more: measuring what the old system actually does before you start, and establishing what is actually in it, because with older software that is rarely written down anywhere any more.

Three levels of legacy modernisation.

The scope of a project depends on the number of applications, the dependencies between them and how much grip you still have on the original code. In the first conversation we'll advise which level fits your situation.

Single-app modernisation · fixed sprint budget

Tackling one critical application

A specific application that is holding the organisation back — a desktop Delphi tool, a Classic ASP portal, an Access database that has blown up. We rebuild or replatform it, keeping the business logic that has built up in it over the years. For a single app, with its dependencies clearly mapped out.

Code reviewTest safety netRebuild or refactorMaintenance handover
Portfolio approach · multiple sprints

Portfolio modernisation with a 6R roadmap

You have a collection of older systems — often the result of an acquisition or years of organic growth. We take stock, classify each system according to the Gartner 6Rs (retire, retain, rehost, replatform, refactor, repurchase, rebuild, replace) and build a roadmap with priorities and sequencing. We then carry out the first tranches ourselves.

InventoryBAML matrixMigration roadmapStrangler fig
Multi-system programme · longer engagement

Programme modernisation with a compliance overlay

For organisations with multi-system legacy where compliance is watching closely: finance with DORA, critical infrastructure with NIS2, healthcare with NEN 7510. We act as orchestrator across multiple suppliers, carry out the complex migrations ourselves, and make sure the audit trail and evidence grow with the programme from day one.

Orchestrator roleDORANIS2 / NEN 7510Multi-vendor

What a legacy project delivers.

Not just new software. Also the insights and the maintenance foundation to continue the modernisation yourself afterwards.

  • Application inventory with TCO and business impactWhich systems are running, what they cost (licences, hosting, maintenance, developer hours), and how critical they are to the business — plotted in a Gartner BAML matrix.
  • 6R classification per applicationA well-founded choice for each system: retire, retain, rehost, replatform, refactor, repurchase, rebuild or replace.
  • Roadmap with sequencing and risk reduction firstWhich migration comes first (to remove risk), which can wait, and how dependencies dictate the order.
  • The modernised applications themselvesThe actual new or replatformed versions, production-ready, with staging and CI/CD. Hosted in the cloud (AWS / Azure / GCP) or on-prem.
  • Test safety net before any code changesEnd-to-end tests on the old implementation, so we don't quietly lose business rules during a refactor or replatform.
  • Knowledge transfer and runbooksDocumentation of the old business logic (often hidden knowledge), runbooks for the new system and training for your maintenance team.
  • Maintenance contract (optional)Ongoing monitoring, patching and further development, at a fixed monthly price. Or a full handover to your own team — your choice.

When legacy modernisation is the right choice.

A few patterns we often come across. If you recognise one of them, it is probably worth a conversation.

Knowledge loss

The original developer has left

A mid-90s or early-2000s system whose builder left long ago. There is no documentation, the code is entangled with conventions nobody remembers, and every change feels like Russian roulette.

Stack graveyard

Too many different technologies

At ICT vendors or after a series of acquisitions: five, six or seven different tech stacks side by side, each with a handful of developers who know it. The maintenance burden becomes unsustainable and integrations are fragile.

Compliance pressure

New legislation affects old systems

DORA, NIS2, the AI Act or NEN 7510 impose requirements on logging, security or data minimisation that your legacy stack can barely meet, if at all. Patching no longer works; modernising is the only route.

Cloud necessity

On-prem hardware at end of life

The physical server running your AS/400 or Oracle Forms application is approaching end-of-life. Replacing it is expensive, and there is no on-prem successor any more. Migrating to the cloud is the logical step.

M&A aftermath

An acquisition has left you with a second stack

You bought a company and, with it, a whole application portfolio on a completely different stack. Two silos side by side is expensive, and consolidating them calls for a modernisation plan.

Scaling ceiling

The old architecture no longer scales

A monolith running on a single server that cannot scale horizontally, a database that can no longer handle the transaction volume, or a desktop app that is not suited to remote work. Scale calls for a new architecture.

The legacy categories we encounter.

No two legacy stacks are alike. Modernising a mainframe is a completely different job from replatforming a Delphi application. The categories below cover the vast majority of what we see in the market.

Mainframe

z/OS, COBOL, JCL

Banks and insurers in particular still run core systems on mainframes. Modernisation often combines a phased decommissioning (rebuild or replace) with temporary façades, so that modern channels can be developed before the mainframe is emptied.

IBM i

AS/400 with RPG applications

Often ERP-like systems that have run stably for years. Options are to replatform to Linux or containers while keeping the data models, or a gradual rebuild with the RPG application as the source of truth during the transition.

Desktop legacy

Delphi, VB6, .NET WinForms, MFC

Construction firms, manufacturers, ICT vendors: lots of sector-specific tools. We replatform to the web or modern desktop (modern .NET, Electron or native web apps) while preserving the workflows users are used to.

Web legacy

Classic ASP, ColdFusion, PHP 4/5, Perl/CGI

Surprisingly many B2B portals still run on these. We modernise to Node.js, .NET, PHP 8 or a modern front-end stack, often with an API layer between old and new so that migration can happen incrementally.

Database legacy

Access, Oracle Forms, SQL Server 2000

Usually smaller applications that have gradually become critical to the organisation. We migrate to a modern backend with an API layer, often combined with a new web front end.

Cloud-naive

LAMP monoliths without containerisation

Not "old" in years, but outdated in architecture: not horizontally scalable, no CI/CD, no observability. We replatform to containers, infrastructure as code and modern deployment pipelines.

Gartner's 6 Rs, extended to eight options.

Gartner's 6R strategy is the industry standard for modernisation decisions. We use an extended variant with eight options, because reality sometimes simply calls for more nuance.

Retire

Decommission

Not every legacy system needs a successor. In a typical portfolio, a considerable share can simply be switched off. That is not failure, it is clearing out. Anything that still has to go is archived in line with retention requirements.

Retain

Keep deliberately

The system is old but works fine and rarely changes. No action. We do monitor the risks (end-of-life of the stack, single points of failure in the people who know it) and schedule a review moment in the roadmap.

Rehost

"Lift and shift" to the cloud

Moving the application from a physical server or VM to a cloud VM without changing the code. Quick and cheap, but the old architecture remains. A good interim step to remove hardware risk.

Replatform

Light changes for PaaS or containers

The code stays largely intact but moves to a container, PaaS database or managed service. More operational gain than rehosting, with limited code impact. Often the sweet spot for desktop and web legacy.

Refactor

Internal restructuring, same functionality

Modernising code internally — modularising it, making it testable, replacing dependencies — without changing its behaviour. Important before a rebuild if there is still a lot of undocumented logic in the system.

Repurchase

Replace with SaaS

Sometimes the old system is something the market has long offered as standard SaaS (CRM, helpdesk, expense management). Replacing it with a commercial product is then more rational than building your own. We guide the selection and data migration.

Rebuild

Complete rebuild with the same scope

Rebuilding the application from scratch, with the same business functionality but a modern stack and architecture. For systems that are strategic, business-critical and where refactoring is no longer cost-effective.

Replace

Replace with something entirely new

Not just replacing the technology but also reviewing the scope. Sometimes, after an inventory, it turns out the old system does what was needed in 2005, but the work process has changed since. In that case we build the new version, not the old one.

Why custom and not just automated translation.

There are good automated translation tools for legacy: Modulus, Asysco AMT (COBOL to .NET), Heirloom for mainframe. We use them where they fit. But in a number of scenarios pure automation falls short and custom work is the right route.

Business logic too specific

The translator doesn't understand the rules

Automated translation transforms syntax: COBOL code into C# code. But the real value of a legacy system often lies in unspoken business rules that have crept into the code over the years. A one-shot translation rarely preserves them.

Strategic importance

Too important for a tool-only approach

For applications that give you a competitive advantage, you want more than a one-to-one conversion. You want the modernisation to also upgrade what the application can do — and that takes design, not translation.

Multi-system orchestration

No tool covers the whole picture

In portfolio programmes, several migrations run in parallel — each with its own tooling, its own supplier and its own risk. Someone has to orchestrate them. That is a role no tool can fill.

Compliance overlay

Audit trail from day one

Healthcare with NEN 7510, finance with DORA, critical infrastructure with NIS2. You can't retrofit an audit trail — it has to be built into the migration from the very first sprint.

Knowledge loss

Nobody can review the output any more

An automated translation produces something. But if the original developer has left and the current maintainer has no idea how the old system worked, nobody can objectively judge whether the result is correct. We take care of that reverse engineering.

Integrated landscape

The application is connected to ten others

Translator X can migrate application A, but application A talks to B, C and D. Those integrations have to move along with it. Custom work and orchestration are then cheaper than six separate migration projects side by side.

How a legacy modernisation works with us.

1

Inventory and stakeholder mapping

We map every application: tech stack, hosting, users, integrations, licences and maintenance costs. At the same time, we identify which business processes run on it and who the owners are. Sometimes it becomes clear at this stage that 10 to 20 per cent of the portfolio can simply be retired.

2

TCO calculation and BAML matrix

For each application, we weigh Total Cost of Ownership against business impact. High-impact, high-cost systems get priority; low-impact, low-cost ones can stay as they are. The outcome is a visual matrix that management can steer by.

3

6R classification and roadmap

For each application, we choose the right strategy from the extended 6R set (retire, retain, rehost, replatform, refactor, repurchase, rebuild, replace). Then we sequence the work: which dependencies dictate the order, where the quick wins in risk reduction are, and how we spread the load across your IT organisation.

4

Test safety net and evidence of behaviour

For systems we are going to refactor or rebuild, we first build a test safety net around the current behaviour: automated end-to-end tests and, where needed, screen recordings of existing user flows. The aim is to prevent unwritten business rules from disappearing in the migration.

5

Strangler fig migration

No big bang. We put a façade in front of the old system and migrate functionality to the new stack piece by piece. Users notice little, and the organisation keeps running. Only once the last piece of functionality has been migrated do we switch off the old system.

6

Hosting migration and infrastructure as code

Where relevant, the new application moves to the cloud (AWS, Azure, GCP) or a container platform (Kubernetes, OpenShift). All infrastructure is defined in Terraform or Pulumi, deployed via CI/CD, and monitored with OpenTelemetry. Staying on-premises is also an option; sometimes it is the right choice.

7

Handover to operations and knowledge transfer

The final phase. We train your operations team, write runbooks for incidents and planned changes, and hand over our knowledge of the business logic we uncovered along the way. After that, you can choose: you run it yourself, or we do it for a fixed monthly fee.

Frequently asked questions.

What clients usually want to know before we start a modernisation project.

What exactly counts as ‘legacy’?
In practice: anything where modern development is structurally difficult. That could be mainframe COBOL, an AS/400 with RPG applications, desktop tools in Delphi or VB6, web platforms in Classic ASP, ColdFusion or PHP 4/5, or database systems built around Access and Oracle Forms. Sometimes ‘younger’ stacks too, such as a LAMP monolith without containerisation. The core pattern is always the same: the tech stack makes change expensive or risky.
How is this different from fixing technical debt?
Technical debt is incremental clean-up within a codebase that otherwise still makes modern choices: upgrading dependencies, adding tests, refactoring code. Legacy modernisation is an order of magnitude bigger: replacing, replatforming or fully rebuilding because the stack itself is the problem. For incremental work within a single codebase, see our technical debt page.
Big bang or strangler fig: which do you recommend?
Almost always strangler fig. Big-bang migrations are popular to plan but dangerous to execute: one mistake and the whole business grinds to a halt. With strangler fig, you migrate functionality piece by piece; users work in a hybrid environment where old and new components run side by side, and you can roll back at any moment. It takes slightly longer, but the risk is a fraction.
How risky is replacing a business-critical application?
The biggest risk is usually not the technology but hidden business logic: rules that are documented nowhere but have lived in the code for years. That is why, before we start, we build a safety net of tests around the old implementation and, where useful, parallel-run scenarios in which old and new process the same input at the same time. That way, every deviation comes to light before the old version is switched off.
Cloud or on-premises after modernisation?
Either works. Cloud (AWS, Azure, GCP) is often the logical choice: faster rollout, better observability, easier scaling. But with strict compliance requirements (some government domains, certain financial workloads, healthcare environments with data residency requirements), on-premises or a sovereign cloud is still common. We advise per application. For the cloud route itself, we have a separate page on platform migration.
Who writes the tests for a refactor?
We do. Before a refactor, we first write tests against the existing implementation (behaviour-based, not implementation-based) so that during the migration we can objectively measure whether the new system does the same as the old one. Along the way we often uncover undocumented edge cases; we document these straight away in the test names so the knowledge is preserved.
What determines the cost?
The number of applications, how well the business logic is documented (poorly documented systems take more reverse-engineering), the number of integrations with other systems, and the compliance overlay. A single-app replatform is fundamentally different from a multi-system programme with a DORA overlay. We pin this down in the first conversation and give you a well-founded estimate.
How long does a project like this take?
It depends heavily on scope. Replatforming a single desktop application to a web app can be done in a few sprints. A portfolio modernisation with ten to twenty applications is a multi-sprint programme, sometimes spread over a longer period in tranches so as not to overload the IT organisation. We map out the planning at the roadmap stage.
What compliance overlays do you come across?
DORA (financial), NIS2 (critical infrastructure), NEN 7510 (healthcare), BIO (government), GDPR (always), and the AI Act when modernising towards an AI stack. We make sure audit evidence grows alongside the project from day one, with no separate compliance phase at the end, because that is usually the point where things get stuck.
Do you also work with our existing IT department?
Almost always. A legacy modernisation is not something an external supplier can pull off alone: your people know the business, the users and the history. We work as an extension of your team, hand over knowledge continuously (not just at the end), and agree clear maintenance responsibilities for delivery. See also our IT modernisation consultancy if you would like a second opinion first.

Talk to us about your legacy portfolio.

A no-obligation introductory call of half an hour. Tell us which systems are running you into the ground, which regulations are coming your way and which part of your team still has a grip on the old stack. We will come back with an initial direction, and we will be honest if it is not a fit for us. Want to look more broadly first? See also our page on platform modernisation consultancy or on enterprise software development.

Edit content