At Databuild, I maintained a legacy PHP application while a replacement .NET platform was being developed. The existing system still supported day-to-day work. Its maintenance could not wait for the replacement to be ready.
That is the practical starting point for a legacy PHP migration: separate the work needed to keep today's service running from the work needed to replace it. Moving an application onto a newer server, improving one workflow and replacing the whole product are different decisions. They do not have to share a release date.
What changed at Databuild
The work combined ongoing maintenance with selected changes. Parts of the application were rebuilt with Laravel and an Angular frontend, exposing an API that clients could use to query information. Older applications were wrapped in Docker so they could move to a newer server, with Ansible making the server setup repeatable.
Those are the outcomes described in the Databuild project record. They establish what was delivered. They do not establish a zero-downtime migration, a particular cost saving or a completion date for the replacement platform, and I would not claim those results from this record.
The useful lesson is that the operating environment could improve while replacement work continued. The existing application remained a piece of software to look after, with its own users and responsibilities.
Separate the server move from the application change
An old application often depends on a particular combination of runtime, extensions and configuration. Changing all of those while also rewriting its business logic makes a failed check harder to explain.
Docker's container documentation describes packaging an application's process and required files in an isolated environment. That is useful for making its runtime explicit. It does not make unsupported PHP supported, repair vulnerable code or replace a database backup. Containers also share the host kernel; they are not a complete copy of the old machine.
For a similar migration today, I would first identify the smallest working unit that can move: the application, its runtime, configuration, persistent files and required connections. Then I would verify its important workflows in the new environment before combining the move with unrelated application changes.
This keeps the question answerable: did the application behave correctly after the environment changed?
Choose a boundary the business can recognise
At Databuild, client information queries were one concrete area for API-based work. That is more useful as a unit of planning than “modernise the backend”. A team can describe who makes a query, what information they need and whether the result is correct.
For another system, the useful boundary might be a report, an import or a customer lookup. I would choose it by looking at the dependencies and the operational benefit, rather than assuming every screen deserves a rewrite.
Before moving a workflow, I would want clear answers to a few questions:
- Which system owns the data while the workflow moves?
- Which callers still use the old route or interface?
- What observable result proves the new workflow works?
- What can be removed once those callers have moved?
A partial migration becomes expensive when both paths remain indefinitely and nobody can explain which one is authoritative. The removal step belongs in the work from the beginning, even when it cannot happen on day one.
Keep maintenance work bounded
Supporting the current application does not mean giving every new request to both implementations. It means deciding which fixes protect current operations, which changes can stand on their own and which belong in the replacement.
For a small team, a short list of critical workflows is a better starting point than attempting to reproduce every historical detail. I would use that list to check the server move and each migrated boundary, including the data written or returned. A process that starts successfully has passed a much narrower test than a customer completing their work.
The DNS rewrite article explores a related decision: keeping a useful product model while replacing the implementation underneath it. Here the immediate concern was continuity while a replacement was still being built.
If you are deciding what to stabilise, move or replace in an older application, a technical audit can establish those boundaries before the work expands into a full rebuild.
