Service · Software development

Replacing your FoxPro application.

Stock management, customer management or administration that still runs on a FoxPro application from the 1990s or early 2000s. The data sits in DBF files on a network drive, and the program starts from a shortcut on a PC running a version of Windows that Microsoft itself hasn't updated for years. We replace FoxPro applications with a modern web application, with a careful export of your existing data and a transition that doesn't bring your daily work to a halt.

↻

A DBF file is not a database, it's a risk.

FoxPro, and later Visual FoxPro, was a popular platform for small and medium-sized business applications in the 1990s and 2000s: administration, stock management, customer management, invoicing. Microsoft acquired developer Fox Software in the early 1990s and released the final version, Visual FoxPro 9.0, in 2007. No new version has appeared since, and regular and extended support ended for good in January 2015. There are no more security updates, no patches and no official support: the platform has stood still for more than ten years.

The underlying data usually sits in DBF files, a simple table format with no real database engine behind it. Each table is a separate file, memo fields are stored in a separate .fpt file, and indexes in a separate .cdx file. That works fine for a single user or a small group on the same network, but there is no serious concurrency layer underneath: with simultaneous writes, a flaky network connection or an application that doesn't shut down cleanly, a DBF file can become corrupted relatively easily. There is no built-in repair function; recovery requires specialist tools and isn't always fully successful.

On top of that comes a second layer of risk. To keep the application running, the underlying Windows version is often itself running in compatibility mode and has been for years, sometimes a version that Microsoft no longer supports either. Application and operating system are then both end-of-life: a double security risk with no single vendor still releasing a patch. Even hiring a FoxPro developer to mitigate this in the short term is becoming increasingly difficult. That makes FoxPro a slightly different kind of risk from a Delphi application or an AS/400 system: not only is the language outdated, the file format underneath lacks any form of modern database protection. Our broader approach is described at replacing legacy software.

How we approach FoxPro projects.

Data export first
Full inventory and export of the DBF tables before anything is built
Rebuilding the logic
Reconstructing business rules from screens, code and actual usage
Phased transition
Module by module, with validation at each step and the old system as a safety net
Data ownership
Full migration with verification and a read-only archive of the old system

From FoxPro to a modern web application.

At their core, all FoxPro projects follow the same three steps: getting the data out without loss, rebuilding the business logic in a modern application, and phasing the transition so operations never come to a standstill.

Approach 01

Data export from the DBF files

The first step in every project

We map every table, field and relationship, including memo fields and index files that are often documented nowhere. In FoxPro, relationships between tables are rarely formalised as foreign keys; we reconstruct them from naming conventions, code fields and how the data is actually used. The data goes into an intermediate format and is validated table by table against the original: record counts, key fields and referential integrity.

Where DBF files turn out to be corrupted already, we document it before building any further. We would rather give you an honest list of missing records at the start than a surprise after the switchover.

DBF inventoryMemo and index filesValidation against the originalCorruption checkCSV/SQL intermediate formatReferential consistency
Approach 02

Rebuilding the business logic

The real work isn't in the screens, but behind them

A FoxPro application consists of forms with procedural code directly behind them: validations, calculations and exception rules are often woven into the screens themselves, with no separate documentation. We reconstruct that logic through code analysis, interviews with the people who use the system every day and observation of how it is actually used, and carry it over into a modern architecture with a proper database underneath.

Not every FoxPro system calls for a full rebuild. For a smaller, well-defined part, a lighter approach may be enough, where the existing system is extended or wrapped rather than replaced; that route is covered on modernising legacy software. With FoxPro, because of the fragility of DBF files, that is more often a stepping stone than a final destination.

Analysing forms and screensReading procedural codeUser interviewsMaking business rules explicitModern architectureTesting against legacy behaviour
Approach 03

Phased transition with data conversion and validation

Never all at once, always module by module

The new application grows module by module alongside the FoxPro application. Each module only goes live once its data conversion has been validated: counts, totals and key fields compared against the old DBF tables. Users work with both systems for as long as necessary, and the FoxPro application remains as a safety net until a sub-process has demonstrably run stably.

Only when all modules have been taken over is the old environment shut down for good. A read-only archive of the final DBF state is kept, in case an old report or a historical correction is still needed.

Module by moduleValidation suiteParallel runningRollback pathCut-over per processRead-only archive

What you have at the end.

A working web application on a modern database, a decommissioned FoxPro environment and an organisation that no longer depends on file locks on a network drive.

Modern web application

Accessible through the browser, no longer tied to one specific PC or network drive.

A real database

A relational database instead of DBF files, with transactions and concurrency that scale with the number of users.

Migration report

Which tables and records have been migrated, which discrepancies were found and how they were resolved.

Decommissioning plan

When and how the FoxPro environment is shut down, and which read-only archive remains.

Management (optional)

Monitoring, backups, updates and further development under a maintenance contract.

Risks we address explicitly.

Replacing FoxPro affects not only technology, but also security, knowledge and accessibility. Four risks that top the list in every project.

Security

Double end-of-life risk

The application has been without support since January 2015, and often runs on a Windows version that no longer receives patches either. We put the new application on a current, supported platform, so security risks at both application and operating system level disappear.

Data

Corruption and data loss

DBF files are vulnerable to corruption during network interruptions, concurrent writes or an application that doesn't shut down cleanly. We carry out a data audit upfront and run a validation suite that compares every migration run against the original.

Knowledge

No more FoxPro developers to be found

The pool of people who still actively know FoxPro is shrinking. Even hiring a temporary developer doesn't solve the underlying platform risk, it only postpones it. We reconstruct the business logic so the knowledge no longer rests with a single scarce specialist.

Access

No web access or remote working

FoxPro is a Windows desktop application, often limited to a single PC or a small network with no mobile or external access. The new web application can be used from any location and any device as standard, with normal user permissions instead of file locks.

How a FoxPro project works.

01Introduction→ 02Discovery & data export→ 03Build & data conversion→ 04Cut-over & maintenance
Step 01

Introduction

Which FoxPro application you have, how many users work with it, where the acute pain is. A no-obligation conversation with IT and operations.

Step 02

Discovery & data export

We inventory the DBF tables, carry out a data audit, interview key users and reconstruct the business logic behind the screens.

Step 03

Build & data conversion

Working modules in sprints, with a validation suite for every conversion run and parallel running alongside the existing FoxPro application.

Step 04

Cut-over & decommissioning

A phased transition module by module, with the old environment eventually switched off and a read-only archive of the final DBF state remaining available.

From FoxPro and DBF to a modern stack.

FoxPro systems differ greatly in size and complexity, but the underlying risks, DBF files without concurrency protection and a language without an active developer pool, are almost always the same. Below is an indication of where we start from and what we build towards.

Where we start from
FoxProVisual FoxProDBF tablesFPT memo filesCDX/IDX indexesWindows in compatibility mode
Target stack, frontend & backend
Next.jsAstroReactNode.jsPython.NET 8PostgreSQL
Migration, infrastructure & integration
ETL conversion scriptsData validation suiteAuth0Azure ADDockerGCP/AWSTerraform

Frequently asked questions.

How long can a FoxPro application safely keep running?
That depends on how much risk your organisation can tolerate, not on how stable the system looks. Visual FoxPro has been unsupported since January 2015: no updates, no patches, no vendor that still responds. The application often also runs on a version of Windows that has itself been end-of-life for years. As long as nothing external interferes and the DBF files don't become corrupted, it can keep going for a long time, until the moment it no longer does.
What if the DBF files are already partly corrupted?
That is more often the reason people get in touch than the exception. We start with a data audit: which tables still open normally, which memo or index files throw errors, which records are missing or duplicated. With specialist recovery tools, the vast majority of corrupted DBF data can usually still be saved. Where that isn't possible, we document which records are missing so you can make an informed choice about any supplementing from old reports.
Can't we just hire a FoxPro developer to keep it going?
That eases the problem temporarily, but doesn't solve the underlying risk. FoxPro developers are scarce and getting scarcer, so the cost and lead time of finding someone keep rising. Even with an experienced developer on board, the application still runs on a platform Microsoft no longer patches and on DBF files without concurrency protection. A temporary developer buys time, not certainty.
Why is the risk greater with FoxPro than with other legacy systems?
With many legacy systems, it is mainly the language that is outdated, while the data sits in a proper database. FoxPro is different: DBF files are not a database server but standalone table files, with no transactions, no serious concurrency control and no built-in repair function. That makes corruption more likely as the number of users grows. We see similar language and knowledge risks with a Delphi application or an AS/400 system, but there the database layer is generally more robust.
How do you make sure we are not left without a working system during the transition?
By never switching over in one go. After the discovery phase and the first data export, we build module by module while the FoxPro application stays in use. Each module is validated against the old data before users work with it, and the old system remains as a safety net until a sub-process has demonstrably run stably. Only once everything has been taken over do we switch off the old environment, keeping a read-only archive of it.
What happens to the reports and exports currently generated from FoxPro?
We inventory these during the discovery phase as part of the business logic, not as an afterthought. A nightly export to the accounting system, a monthly report for management or a manual correction routine have often become a silent part of the process over the years. We map them through interviews and by observing how the system is used, and we build the equivalent report in the new application before the old one is switched off.
Do we retain ownership of the new application and the data?
Yes, fully. Code, infrastructure, documentation and credentials are put in your name, in a repository that you manage yourself or that is handed over at the end of the project. The migrated data also remains yours, with a documented export format. If you choose our maintenance layer after delivery, that ownership situation does not change: maintenance is a service you can cancel, not an arrangement that locks you in.

Talk to us about your FoxPro system.

A no-obligation introductory call of half an hour. We will listen to what is running now, the state of the DBF files and what has prompted you to look at it now.

Edit content