Service · Software development

Replacing legacy software.

Old business software that still runs but that nobody dares to touch. A FoxPro database from 1998, a Delphi application whose builder left years ago, a Lotus Notes system that only keeps working on one laptop. We replace or modernise legacy software without bringing your operations to a halt: in phases, with your data preserved, and with an approach that matches the complexity of your existing landscape.

↻

Legacy is not a technical problem; it is a business risk.

Most organisations we speak to did not postpone this out of laziness. They postponed it because the old system still runs, because the original supplier is gone, because nobody knows exactly what the system does any more, and because the thought of a replacement brings a tension nobody wants on top of everything else. Until the moment when that one server staying up, or that one developer who still understands the code leaving, suddenly threatens the business.

We are used to walking into that situation. An outdated Access file that drives the financial administration. An ASP.NET WebForms application still running on Windows Server 2008. An Exact Globe installation that needs to move to Exact Online. Our approach starts with understanding what is there, before deciding how to replace it, and which parts can perfectly well stay for a few more years.

The most common mistake in legacy replacement is the idea that you can swap the old system for a new one in one go. In any non-trivial project you run into undocumented flows, forgotten integrations and unwritten business rules. That is why we almost always choose a pattern in which the old and new systems live side by side for a while and the old one is phased out gradually. That sounds clumsier than a big bang, but in practice it is almost always both faster and safer.

How we approach legacy projects.

Strangler first
Old and new run in parallel, with the old one gradually switched off
Discovery phase
We document what is there before we replace it
Data ownership
Full migration with an audit trail and rollback path
Build or buy
Assessed per module — custom only where it really differentiates

Five ways to replace legacy software.

Every situation calls for a different approach. Which route fits depends on the scope, the age of the stack, the availability of documentation and the number of external systems that talk to it. The three clusters below together cover the vast majority of projects we get involved in.

Approach 01

Strangler pattern — phased decommissioning

The most commonly used route for larger systems

The new system grows module by module alongside the old one. We place a routing layer in front of the old application so that we can redirect each individual part — the simple modules first, then the complex ones — to the new codebase as soon as it is ready. The old system keeps running for as long as it still contains parts that have not been replaced, and is switched off once the last flow has been taken over. This approach — described by Martin Fowler as the strangler fig pattern — works particularly well for large applications where a one-off rewrite is unfeasible or too risky.

In practice, this means your end users work with two screens for months (or, better, with a single screen that gradually switches over under the hood) while the old system is emptied step by step. That gives your organisation time to learn the new way of working, and there is never a moment when everything switches at once. No big bang, no weekend when operations grind to a halt, no all-or-nothing risk.

Routing layerModule by moduleParallel runningAnti-corruption layerFeature flagsPhased rollout
Approach 02

Rewrite or build new with data migration

For compact systems with a clear scope

A full rebuild is only advisable for relatively well-defined systems where the scope is well documented and the number of external integrations is limited. We build the new application on a modern stack, copy the data across through a validated migration and plan a single cut-over moment when the old system is switched off. Beforehand, both systems usually run in parallel so that we can run comparative tests on real data.

The biggest pitfall of this route is feature creep: during the rebuild, new wishes keep coming in because "we're starting from scratch anyway". We keep a tight grip on this by first building a zero version that is functionally identical to the old system, and only then adding improvements in a follow-up project. That avoids scope discussions and keeps the cut-over achievable. For situations that resemble this route, our enterprise software development service also covers the heavier stack choices.

Full rebuildData migrationCut-over planFeature parity firstValidation suiteRollback scenario
Approach 03

Lift-and-shift, integration layer or buy with custom

When the old system can partly stay

Not every legacy system needs to be replaced straight away. Sometimes a lift-and-shift is enough: the old application keeps running but is moved to modern infrastructure and wrapped in a new API layer, so that other systems can talk to it through a clean interface. Other times we opt for a SaaS package for the standard part — for example a new accounting package or CRM — and build only the part unique to your organisation as custom software on top. Our digital transformation consultancy often starts with that trade-off.

We make the build-vs-buy decision per module, not for the system as a whole. For your accounting there is usually no reason to build custom software — there is a perfectly good SaaS for that. For the part that sets your way of working apart — the part that was once built as custom software in the old system, and the reason you never switched to a standard package — we do build custom. The result is a hybrid landscape in which the standard part is low-maintenance and the custom part truly fits your workflow.

Lift-and-shiftAdding an API layerBuild vs buyHybrid landscapeSaaS integrationCustom add-on

What you have at the end.

A modern system in production, a decommissioned old server and an organisation that no longer depends on one person who understands the old code.

Production + staging

Two environments, in your own cloud or hosted by us. Your choice.

Codebase + architecture docs

Full source code, build instructions and an overview of all the decisions made.

Migration report

Which data was migrated, which validations were run and where discrepancies were found.

Decommissioning plan

How and when the old system is switched off, and which read-only archive remains.

Management (optional)

Monitoring, backups, security patches and further development under a maintenance contract.

When a legacy project becomes unavoidable.

Four patterns in which postponing is no longer an option, and in which we are usually invited to an audit conversation first, before anything concrete is planned.

Stack

The underlying technology is no longer supported

A FoxPro database, Delphi 7, Visual Basic 6, an outdated version of Lotus Notes or a COBOL mainframe that no longer receives patches. Microsoft ended support for the operating system or runtime years ago. The system still works, but every security incident becomes an acute crisis because there is no longer a vendor who can help.

Knowledge

The original developer is gone

The application was built by a single in-house developer or by a small agency that has since closed down. Nobody in your organisation knows the codebase well any more. Changes take days of investigation before a single line is altered. Getting a second developer up to speed on the old stack is harder and more expensive than rebuilding on a modern one.

Vendor

The vendor no longer supports the product

A software package whose vendor is heading towards end-of-life, for example an ERP vendor phasing out its classic on-premise product in favour of a cloud product. Or a niche tool whose maker has been acquired and the product scaled back. You are being pressured to migrate along with it and want to take control of what happens yourself.

Integration

Hidden integrations are choking the system

Ten other systems talk to the old system through a motley collection of file exports, shared databases, scripts and manual imports. Nobody has the full overview. A change to the old system can easily break three other processes. At this point the old system effectively becomes a single point of failure for your entire landscape.

Risks we address explicitly.

Replacing a legacy system is not a technical project; it is a change that affects your operations. These are the four risk categories we put at the top of every project.

Data

Data loss during migration

Old databases are often full of illegal characters, duplicate records and missing references that were never noticed in production because the old system tolerated them. We carry out a data audit up front, build a validation suite that compares every migration run against the original, and keep a rollback path open until after the cut-over.

Functionality

Loss of functionality and forgotten flows

The old system still did three things nobody was aware of any more: a nightly export, a specific report for management, a one-off correction button. We hold stakeholder interviews with every user group, run shadow tests in which old and new process the same inputs in parallel, and keep a list of "small buttons" that would otherwise disappear at cut-over.

Continuity

Business disruption during cut-over

A cut-over that goes wrong costs days of productivity and weeks of trust within your team. We phase every transition so that one sub-process moves over at a time, schedule cut-overs for quiet periods in your operation, and keep a rollback script ready. Only when a sub-process has run stably for several days do we take the next step.

Adoption

Resistance from users and key people

People who have worked with the old software for years initially experience a new system as a step backwards, even when it is objectively better. We involve key users from sprint one, build workflows that respect the old shortcuts and organise training so the transition does not feel like a loss. No change-management theatre, just practical support.

How a legacy project runs.

01Introduction→ 02Discovery→ 03Build & migration→ 04Cut-over & maintenance
Step 01

Introduction

Which system is in place, how old is it, who still knows it, which pain is most acute. A no-obligation conversation with IT and operations.

Step 02

Discovery & architecture

We document the old system, interview key users, run a data audit and choose per module between rewrite, lift-and-shift, build or buy.

Step 03

Build & data migration

Working modules in sprints, running in parallel alongside the old system, a validation suite for data migration and regular shadow tests.

Step 04

Cut-over & decommissioning

Phased transition per sub-process, a rollback path ready, the old system emptied and eventually switched off — a read-only archive remains available.

Stacks we migrate from and build towards.

We come across many old stacks — sometimes the old stack itself is still viable and we add a modern layer on top, sometimes full replacement is the only route. Alongside this page, our custom software service and the broader overview under software development may also be relevant starting points.

Legacy stacks we encounter
FoxProDelphiVB6Lotus NotesAccessCobolPowerBuilderASP.NET WebFormsAS/400 RPGExact Globe
Target stack — frontend & backend
Next.jsAstroReactVueNode.jsPython.NET 8PostgreSQLRedis
Migration, infrastructure & integration
Strangler routingETL pipelinesAuth0Azure ADGCP/AWSTerraformDockerAnti-corruption layer

Frequently asked questions.

How big is the risk that operations grind to a halt during the replacement?
Manageable — provided you opt for a phased approach rather than a big bang. In almost every project we do, the old system runs alongside the new one for months and is only switched off once all sub-processes have demonstrably been taken over and are stable. The main risk is not the technical side, but missing an undocumented flow — which is why we carry out stakeholder interviews per user group up front and run shadow tests in which the old and new systems process the same input, so deviations become visible before cut-over.
How long does a project like this take?
That depends heavily on the scope, the age of the stack, the number of external integrations and how much documentation and knowledge is still available. A compact system with well-documented flows and few integrations can be replaced within a project of a few sprints. A large, integrated landscape with multiple modules and dozens of integrations requires a project spanning many sprints, often phased over a longer period in which one sub-process at a time goes into production. We give an honest estimate after the discovery phase — before that discovery, any number is a guess that could land you in trouble.
Can we keep working in parallel with the old system?
Yes, and that is the route chosen in almost every legacy project. We place a strangler layer in front of the old system so that traffic can be redirected module by module to the new application as soon as it is ready. Your end users work with both systems at the same time for a while, or — if we can solve it more elegantly — with a single screen that gradually switches over under the hood. This means there is never a moment when everything moves over at once, and so never a risk of the whole operation depending on one successful cut-over.
How reliable is the data migration?
We start with a data audit of the old system: how many records it holds, which fields are incomplete, which references are no longer valid, which data is mission-critical. On that basis we build a migration pipeline with a validation suite that compares every run against the original — counts, totals, key fields, referential integrity. Until after cut-over we keep the old system available read-only so that rollback always remains an option. For financial data and data subject to statutory retention obligations, we keep an archive copy of the old system in any case.
What if the original developer has left and nobody understands the code any more?
This is one of the most common starting points for our legacy projects, and it is not a blocker. In a discovery phase we reverse-engineer the existing system: code analysis, interviews with end users about their actual workflows, screen recordings of everyday use and analysis of the database to reconstruct the underlying business rules. We accept that we will never recover 100% of the old logic, which is why we also set up shadow tests in which old and new run in parallel and any deviations become visible before the cut-over.
What determines the cost of a legacy replacement?
The scope of what is being replaced, the number of integrations with other systems, how well the existing system is documented, the number of user groups and the complexity of the data migration. A lift-and-shift with an API layer on top is a different project from a full rebuild of a mission-critical ERP. We never give a price before the discovery phase: without insight into what is there, any number is a guess. After discovery you receive an honest estimate with a phased scope, so you can decide which part is tackled first.
Do you replace everything at once or in modules?
Almost always in modules. A full rewrite in one go is only defensible for compact, well-defined systems. In almost all other cases we choose the strangler pattern: the new system grows alongside the old one, and the old one is gradually phased out. This means you have a first part of the process in production after just a few sprints, instead of only seeing something at the end of a long project. It lowers the risk, gives your team time to get used to it and keeps the project manageable.
Do you work with our internal IT department?
Almost always. In legacy projects we almost certainly touch existing systems: ERP, accounting, AD/SSO, file shares, sometimes a legacy WMS or CRM. We work transparently with your internal IT and, where necessary, with external vendors who maintain the adjacent systems. Clear API contracts, documented integrations and an incident runbook are standard. At the end of the project our code is handed over to your team, or we take over maintenance under contract, depending on what you prefer.
Do we retain ownership of the new software?
Yes, fully. The code, infrastructure, documentation and credentials are put in your name. We work in a repository that you manage or that we hand over to you at the end of the project. Even if you opt for our support after delivery, all code and infrastructure remain yours: maintenance is a service, not vendor lock-in. The same applies to the data: you own all records at all times, with a documented export format for future migrations.

Talk to us about your legacy system.

A no-obligation introduction of half an hour. We listen to what is running now, where it hurts and what has prompted you to look at it now, even if it turns out that a replacement is not the right route at this moment.

Edit content