Legacy PHP, moved
onto a supported version.
Your host is dropping PHP 5.6 or 7.4, the original developer is long gone, and a rewrite quote just arrived with five figures on it. There is a cheaper path: upgrade the application you already have. Prepaid in Hour Blocks of 6, 12 or 24 hours, working on a staging copy first so production is never the experiment.
Within two business days
Your message goes straight to the studio. No sales queue, no account manager in between.
Prepaid Hour Blocks
Buy 6, 12, or 24 hours up front at $30/hr. Unused hours never expire.
10 live products
PHP 8 in production across our products, and a habit of moving old code forward without a rewrite.
You own the code
Full source, in your repository, with the reasoning written down. No lock-in to us or anyone else.
What actually goes wrong
in an old PHP application.
Modernization is not one job, it is six overlapping ones. Here is what each involves, so you can tell whether the quote you got elsewhere covered them.
The PHP version jump itself
Going from 5.x or 7.x to 8.x is a sequence of specific removals, not a vague risk. The mysql extension vanished in PHP 7 and every query built on it has to move to PDO or MySQLi. each(), create_function() and curly-brace string offsets went in 8.0. Type juggling in comparisons became stricter, so a login check that relied on a loose comparison can change meaning silently. Dynamic properties were deprecated in 8.2, which breaks old model base classes without an obvious error.
- mysql_* to PDO or MySQLi
- Removed functions and constructs replaced
- Loose-comparison behaviour reviewed
- Dynamic property deprecations resolved
- Encoding and serialisation edge cases
- One minor version at a time, verified
Dependencies that stopped moving
The PHP core is usually the easy half. The hard half is a dependency that stopped being maintained in 2017 and refuses to install on a modern PHP. Each one gets a decision rather than a pin: replace it with a maintained equivalent, fork and patch the two files that matter, or absorb the small part of it you actually use and delete the rest. A project whose composer.json has been pinned for six years is not stable, it is frozen.
- Composer dependency audit
- Abandoned package replacement
- Minimal forks where replacement is worse
- Vendored or copy-pasted libraries identified
- Known vulnerable versions flagged
- A lock file that can move again
Finding what will break before it does
Reading fifty thousand lines by hand is not a plan. A PHP compatibility ruleset over the whole tree produces a concrete list of incompatibilities with file and line numbers, which becomes the scope. PHPStan gets introduced at a low level and raised gradually so it is useful rather than a wall of noise. Where a rewrite of repetitive syntax is genuinely mechanical, Rector does it consistently instead of a human doing it eight hundred times with one typo.
- PHP compatibility ruleset across the tree
- PHPStan introduced at a workable level
- Rector for mechanical, reviewable rewrites
- Dead code and unreachable routes identified
- A scoped list before an hour is spent
- Findings ranked by business risk
Not breaking the undocumented rules
Old applications carry undocumented business rules, and those rules are the thing you are actually paying to protect. Before changing anything we put characterisation tests around the flows that earn money: checkout, login, invoice generation, whatever yours are. They do not judge whether the behaviour is correct, only that it stays the same. That is what makes an upgrade provable rather than hopeful.
- Characterisation tests on money flows
- A staging copy with real-shaped data
- Side-by-side output comparison
- Database backup and tested restore
- A rollback plan written before the deploy
- Cutover during your quiet hours
The security debt underneath
Applications written before prepared statements were a habit tend to concatenate SQL, echo user input straight into HTML, store passwords with MD5, and accept forms with no CSRF token at all. The upgrade is the natural moment to fix these, because you are already touching the code and already testing it. Password hashes can be migrated transparently on next login, so nobody has to be forced to reset.
- SQL injection: prepared statements throughout
- Output escaping and XSS hardening
- Transparent password rehashing on login
- CSRF tokens and session hardening
- File upload validation and storage
- Secrets moved out of the repository
The server it runs on
Old PHP rarely sits alone. It usually comes with an operating system past end of life, a MySQL version that will not restore onto anything modern, and a deployment process that consists of one person and an FTP client. Moving the application to a current stack is often the same project, and it is where a lot of the real risk lives - so it gets a runbook, not folklore.
- Move to a supported OS and PHP build
- MySQL or MariaDB version migration
- TLS, HTTP headers and redirects
- Deployment replacing manual FTP
- Cron jobs and scheduled tasks carried over
- A runbook your own team can follow
What you have at the end.
Modernization is worthless if it leaves you dependent on the person who did it. Everything below exists so the next upgrade does not need us.
A compatibility report
The concrete list of incompatibilities with file and line numbers, ranked by risk, produced before the work starts. It is yours whether or not you continue.
An upgrade in steps
One commit per category of change rather than a single ten-thousand-line drop. If something surfaces in production a week later, the cause is findable.
Characterisation tests
Tests pinning the behaviour of your critical flows. They outlive this project and make the next change safe too.
A staging environment
A working copy on the new PHP version that you can click through and sign off before anything touches live traffic.
Deploy and rollback steps
Written down: how to deploy, how to roll back, what to watch for in the first hour, and who to call if it is not us.
An honest list of what is left
The debt we did not touch, why, and what it would cost. No pressure to buy it - you should know what is under the floor either way.
The PHP 8 destination,
running right now.
Client work stays under NDA, so what we show is what we run ourselves: modern PHP 8 products of our own that show what the destination looks like.
Legacy first, rewrite last
Old applications get patched, stabilised and moved forward one step at a time, with the behaviour pinned by tests. A rewrite is the last option we reach for, not the first.
CodeIgniter maintenanceLearnCoachAssist
PHP 8.2 and Laravel 12 with Stripe subscriptions, running in production. This is the kind of codebase an upgrade is heading towards: maintained dependencies, modern language features, and a test suite that makes the next change cheap.
Read the case studySlashKeys
Laravel 13 on SQLite with self-hosted mail through Postfix and OpenDKIM. Relevant here because modernization usually means touching the server as well as the code, and that is work we do ourselves rather than subcontract.
Read the case studyFour steps, no discovery call
you have to sit through.
Nothing touches production until you have clicked through a working copy on the new version and said yes.
Tell us the problem
A few sentences on what you have and what you need. Rough is fine - we ask the questions that matter and tell you honestly if it is not a fit.
Pick an Hour Block
Prepay a block of hours - 6, 12, or 24. The block is the budget: we work until it is used, or you top up.
Work in the open
Analysis first and a scoped list of what breaks, then the upgrade in reviewable steps on a staging copy, with the money flows tested before and after.
Handover and support
Cutover in your quiet hours with a rollback plan already written, then the runbook, the report, and the honest list of what is still under the floor.
Bought in
prepaid Hour Blocks.
No volume games and no agency margin on top. You buy the block of hours that fits the size of the job, so you know the number before we start rather than after.
Typically enough for a focused fix, a small feature, or an integration you are stuck on.
Start with StarterTypically enough for a working prototype, or one well-scoped feature built and shipped.
Start with StandardTypically enough for a larger build with integrations, auth, or billing wired in.
Start with ProEvery Hour Block is hours at $30/hr with no discount. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire - roll them into the same project or a later top-up. If the work runs long, you buy another block; nothing is billed without you agreeing to it first.
Frequently asked.
Do we have to rewrite the application?
Almost never, and we will tell you when the answer is genuinely yes. A rewrite throws away every undocumented business rule the old code quietly enforces, and those rules are the actual asset. The default plan is to get the existing application onto a supported PHP version, remove the things that block future upgrades, and leave the behaviour identical.
What is an Hour Block, and what if the job takes more or fewer hours?
An Hour Block is a prepaid block of hours: Starter is 6 hours for $180, Standard is 12 hours for $360, Pro is 24 hours for $720. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire and roll into the same project or a top-up. If the work runs over, you buy another block, and nothing gets billed without you agreeing to it first.
How far back can you go?
PHP 5.2 era code is still something we can read and move. Plain procedural PHP with no framework at all is fine as well, and is often easier to upgrade than a dead framework.
What actually breaks between PHP 5, 7 and 8?
The big ones are the mysql extension removed in PHP 7, each and create_function removed in 8.0, curly-brace string offsets removed in 8.0, stricter type juggling in comparisons, and dynamic properties deprecated in 8.2 which breaks older ORMs and model base classes quietly rather than loudly. On top of that sit your own dependencies, which are usually the harder half.
How do you avoid breaking things nobody documented?
Static analysis first, so the machine finds what a human would miss: a PHP compatibility ruleset over the whole tree, then PHPStan at a low level raised gradually. Then characterisation tests around the flows that earn money, so there is something to compare against. Then the upgrade itself, one PHP minor version at a time, on a staging copy before anything touches production.
The original developer is gone and there is no documentation. Is that a problem?
That is the normal starting position for this work. What we need is the code, the database, and access to the server or a copy of it. From those three we can reconstruct how it is deployed and what it depends on. If something is truly missing, such as a paid library with no source, we tell you before spending hours on it.
Can you also move it off the old server?
Yes. Old PHP usually comes with an old operating system, an unsupported MySQL, and TLS that browsers will start refusing. Moving to a current stack with the application working identically is a normal part of this job, and you get a written runbook rather than a server only we understand.
How do we start?
Send a few sentences through the form on this page: what the application does, roughly how old it is, what PHP version it runs on, and what is forcing the change. You get a reply from us directly, usually within two business days, with an honest read on whether an upgrade or a replacement is the cheaper answer.
Tell us about the old PHP app.
What it does, roughly how old it is, what PHP version it runs on, and what is forcing the change. A few sentences is plenty - we read every message and reply within two business days with an honest read and the Hour Block that fits.
Prefer email?
[email protected]