Service · Software development

Modernise your Delphi application.

A grey Windows application that has been running for years, built in Delphi with Object Pascal and a Visual Component Library interface that nobody dares to touch any more. The database underneath is a Paradox file, an InterBase server or a Firebird installation that has never been updated. We build a modern, web-based layer alongside it, in phases and without bringing day-to-day operations to a halt.

↻

A Delphi application is not ordinary legacy software.

Delphi applications share a recognisable set of traits. A locally installed .exe on every workstation, a typical grey VCL screen with square buttons, and a database that is almost never a modern relational server but a Paradox file, a dBase table or an InterBase or Firebird installation accessed through the Borland Database Engine. There is no web access, no mobile version, and the application is often tied to one specific version of Windows because drivers or the BDE configuration no longer work on a newer one.

In practice, that often makes replacing a Delphi application more urgent than the average legacy replacement we describe on replacing legacy software. The number of developers still actively working with Object Pascal and the Visual Component Library has shrunk sharply, and the application usually runs on a single machine or a single specific Windows version rather than on redundant infrastructure. If that one machine fails, an entire business process often grinds to a halt: administration, planning, inventory or production.

This page goes deeper into our broader approach to modernising legacy software, tailored specifically to what makes Delphi applications difficult: the closed VCL architecture, the lack of integration options, and a database layer that is rarely accessible in a modern way. Our approach starts with understanding exactly what the application does, before we decide how and in what order to replace it.

How we approach Delphi projects.

Strangler first
A new web/API layer alongside the existing Delphi app, taking over function by function
Discovery phase
Screens, business rules and database structure mapped out before we build
Data ownership
Full migration from Paradox, InterBase or Firebird with validation and a rollback path
Build or buy
Assessed per module, custom only where it genuinely sets you apart

Three ways to modernise a Delphi application.

Which route fits depends on the size of the application, the number of screens, the state of the underlying database and the number of external systems that talk to it. The three approaches below together cover the vast majority of Delphi projects we get involved in.

Approach 01

Strangler pattern: a new web/API layer alongside the Delphi app

The standard route for Delphi projects

We build a new web and API layer that runs alongside the existing Delphi application and exposes the same underlying data and business rules. Function by function, usually starting with the simplest screens, we move users over to the new layer. Meanwhile the Delphi application stays active for everything that has not yet been taken over, and is only switched off once the last function has been migrated.

For your team, this means there is never a moment when everything changes at once. No weekend when administration, planning or production grinds to a halt, no all-or-nothing risk, and room to get used to the new screens while the familiar old application still exists in the background for whatever is not yet ready.

Web/API layerModule by moduleParallel runningAnti-corruption layerFeature parity firstPhased rollout
Approach 02

Data migration from Paradox, InterBase or Firebird

The core of every Delphi project

Most Delphi applications run on a Borland Database Engine connection to Paradox tables or dBase files, or on an InterBase server. Firebird is the open source fork that emerged from InterBase in the early 2000s and is often found in practice as a later replacement, sometimes in a version that has not been updated for years. We start with a data audit: how many tables and records there are, which fields are missing or inconsistent, and which business rules exist only implicitly in the Delphi code and not in the database itself.

Based on that, we build a migration path to a modern relational database, with a validation suite that compares every migration run against the original on record counts, key fields and referential integrity. We keep the old Paradox, InterBase or Firebird environment available read-only as an archive well beyond the cut-over, so a rollback path is always open.

Data auditParadox/dBase exportInterBase/Firebird migrationValidation suiteReferential integrityArchive copy
Approach 03

Lift-and-shift: an API layer around your existing Delphi logic

When part of the Delphi app can stay for now

Not every part of a Delphi application needs replacing straight away. Sometimes it is enough to build an API layer around the existing logic and database, so that other systems and a new web interface can talk to it through a clean interface without the underlying application being rebuilt immediately. The Delphi application then keeps running in the background, often on virtualised or isolated infrastructure so that you no longer depend on a single physical machine.

We make the build-vs-buy decision per module. For a standard process such as accounting, there is often no reason to build custom software, as a suitable package already exists. For the part that was built in Delphi precisely because it makes your way of working unique, we build a modern replacement with a clear focus.

API wrapperVirtualisationBuild vs buyHybrid landscapeIntegration layerCustom add-on

What you have at the end.

A web-based application that no longer depends on the goodwill of a single workstation, a single Windows version and a single developer who still understands the Delphi 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 from Paradox, InterBase or Firebird was migrated, and which validations were carried out.

Decommissioning plan

How and when the Delphi application will be switched off, and which read-only archive remains.

Management (optional)

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

What makes a Delphi application recognisable.

Four characteristics that make Delphi applications slightly more urgent than the average legacy replacement, and which usually lead to us being invited for an introductory meeting before anything concrete is planned.

Platform

One Windows version, often one machine

The application is built with the Visual Component Library and runs best, or sometimes only, on a specific Windows version with the matching drivers and the Borland Database Engine configured. Upgrading the operating system is a risk in itself. If the machine fails, an entire process often grinds to a halt.

Knowledge

Almost no Delphi developers left to find

Object Pascal and the VCL are no longer an active choice for new projects, so the pool of developers who still know the language and framework well has shrunk considerably. Getting a new developer up to speed on an old Delphi codebase takes more time and effort than rebuilding on a modern stack.

Database

A Paradox file or an old InterBase or Firebird server

The data is often held in local Paradox tables or dBase files accessed via the Borland Database Engine, or in an InterBase or Firebird server that hasn't been updated for years. Backups, replication and security patches are usually minimal on these database layers.

Integrations

Barely able to integrate with modern systems

There is no REST or JSON API, only file exports, shared folders or manual re-keying into other systems. Reporting often runs through QuickReport or Crystal Reports, for which we have a separate deep dive on replacing Crystal Reports. Every integration that exists today is a manual process that has to be redesigned when you replace the application.

Risks we address explicitly.

A Delphi modernisation is not a technical project, it is a change that affects your operations. Four risk categories that we put at the top of every project.

Data

Data loss when migrating from Paradox or Firebird

Old Paradox tables and InterBase or Firebird databases often contain duplicate records, missing references and characters that the legacy system silently tolerated. 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 well beyond the cut-over.

Functionality

Functionality erosion and forgotten screens

The Delphi application often still does something nobody is aware of any more: a nightly export, a specific report for the board, a correction screen that is only opened once a quarter. We run stakeholder interviews per user group and carry out shadow tests in which the old and new systems process the same input in parallel.

Continuity

Business disruption during cut-over

Because Delphi applications often run on a single machine, the risk of a disrupted transition is greater than in a phased, redundant environment. We phase every transition so that one sub-process switches over at a time, schedule cut-overs for quiet periods and keep a rollback script ready.

Adoption

Resistance from users accustomed to the old screens

People who have worked with the same VCL screens for years initially find a web interface unfamiliar, even when it is objectively faster and more accessible. We involve key users from the start, build workflows that respect the old keyboard shortcuts and sequence, and provide training so the transition doesn't feel like a loss.

How a Delphi modernisation project works.

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

Introduction

Which Delphi application is in place, how old is the code, which database sits underneath, and which pain points are most acute. A no-obligation conversation with IT and the departments that use the application every day.

Step 02

Discovery & architecture

We document the existing screens and business rules, interview end users, run a data audit on Paradox, InterBase or Firebird, and choose per module between strangler, lift-and-shift or a full rewrite.

Step 03

Build & data migration

Working modules delivered in sprints, running in parallel alongside the existing Delphi application, with a validation suite for the data migration and regular shadow tests on real input.

Step 04

Cut-over & decommissioning

A phased transition per sub-process, with a rollback path ready, then emptying the Delphi application and eventually switching it off. A read-only archive of the old database remains available.

From Delphi, Paradox and Firebird to a modern stack.

Delphi is a development platform originally from Borland, later Embarcadero, based on the Object Pascal programming language with the Visual Component Library as its GUI framework. Database access traditionally ran through the Borland Database Engine to Paradox and dBase files, or to InterBase, of which Firebird is the open-source fork. We carry out similar projects for other stacks from the same era, such as replacing FoxPro applications. See also the broader overview under software development as a starting point.

Delphi stack we encounter
Delphi / Object PascalVCLBorland Database EngineParadoxdBaseInterBaseFirebirdQuickReport / Crystal ReportsRAD Studio
Target stack, frontend and backend
Next.jsAstroReactNode.jsPython.NET 8PostgreSQLRedis
Migration, infrastructure & integration
Strangler routingETL pipelinesAPI layerAuth0Azure ADGCP/AWSDockerAnti-corruption layer

Frequently asked questions.

How do I tell whether our application is a Delphi application?
A number of signs almost always come up: a grey Windows interface with square buttons and a typical VCL look, an .exe installed locally on every workstation, error messages that refer to the Borland Database Engine or a BDE alias, and a database made up of Paradox tables, dBase files or an InterBase or Firebird server. Often the application has been running for many years without any significant changes to its architecture. If that sounds familiar, you are quite likely dealing with Delphi.
Why is replacing a Delphi application often more urgent than with a more modern stack?
A Delphi application is usually more tightly bound to one specific Windows version, one set of drivers and sometimes even one physical machine than the average web application. The number of developers still actively working with Object Pascal and the Visual Component Library has shrunk sharply in recent years, making it increasingly difficult to replace staff or extend functionality. On top of that, a Delphi application rarely offers web access or a mobile version, while the rest of your software landscape has moved in that direction. The combination of scarce expertise, a fragile platform and a lack of accessibility makes postponing riskier than with newer systems.
Can we simply keep working with the existing Delphi application during the modernisation?
Yes. We almost always work with a strangler pattern: a new web and API layer is built alongside the existing Delphi application, and traffic is redirected to the new layer function by function as soon as each one is ready. Meanwhile, the old application keeps running for the parts that have not yet been taken over. Your team therefore never has to deal with a system that switches over all at once, and there is no moment when the entire operation depends on a single cut-over.
What happens to our data in Paradox, InterBase or Firebird?
We start with a data audit: how many tables and records there are, which fields are missing or corrupted, and which business rules are implicitly embedded in the Delphi code rather than in the database itself. Based on that, we build a migration path to a modern relational database, with a validation suite that compares every migration run against the original on record counts, key fields and referential integrity. We keep the old Paradox, InterBase or Firebird database available as a read-only archive until well after the cut-over.
Is it possible to add just a web interface without replacing the entire Delphi application?
Yes, that is exactly what a lift-and-shift approach involves. We build an API layer around the existing Delphi logic and database, so that other systems and a new web interface can communicate with it through a clean interface, without the underlying application having to be rebuilt straight away. This is a good intermediate step when certain parts of the Delphi application can remain in use for a while, or when external accessibility is the only pressing problem.
What if the original Delphi developer can no longer be found?
With Delphi projects, that is the rule rather than the exception, and it is not a blocker. In the discovery phase, we reverse-engineer the existing application: analysing the Object Pascal source code where available, interviewing end users about the actual workflows, and analysing the database structure to reconstruct business rules that are documented nowhere. Where the source code itself is missing, we reconstruct the behaviour from the database and observed usage, and set up shadow tests to surface deviations before the cut-over.
What determines the approach and scope of a Delphi modernisation project?
The main factors are the size of the application, the number of screens and reports, the state of the underlying database, the number of integrations with other systems, and how well the source code and business rules can still be understood. A compact Delphi application with a straightforward Paradox or Firebird database is a different undertaking from an extensive production system with dozens of screens and integrations with accounting, planning and inventory. We give you an honest estimate of the approach and phasing after the discovery phase, not before.
Will we retain ownership of the new software and data?
Yes, completely. The code, infrastructure, documentation and credentials are put in your name, in a repository that you manage or that is handed over to you at the end of the project. The migrated data also remains entirely yours, with a documented export format for any future migrations. If you choose our management layer after delivery, all code and infrastructure still remain yours. Management is a service, not vendor lock-in.

Talk to us about your Delphi application.

An introductory conversation, with no obligation. We listen to what is running now, which database sits underneath, where the pain points are and what has prompted you to look at it now, even if it turns out that replacement is not the right route at this point.

Edit content