On this page
The PHP project stops releasing security fixes for 8.2 on December 31, 2026. After that date the branch keeps running, but upstream stops patching it, which turns a version choice into a security decision. Some distributions keep maintaining their own packages past that date, as Debian's LTS project does, so confirm which arrangement covers your servers. If nothing extends it, the move to a supported branch is a small project with a date attached. This is the order to run it in.
Service in this guide: Devoptly's PHP audit and migration is the fixed-price work referenced at the end, where the report states the effort before you commit to anything.
Who this checklist is for
This is for self-hosted PHP: WooCommerce and Magento stores, WordPress sites, Laravel and Symfony applications, and the smaller properties around them such as landing pages, client portals and old campaign subdomains.
If you sell on Shopify, there is nothing for you to patch on Shopify itself. You do not run or manage the PHP behind your Shopify store. This matters for the PHP sites you run beside it, and for agencies holding a list of client properties.
Start by writing that list down. One domain often has several PHP installations behind it, and the forgotten one is usually the oldest.
Confirm the branch and patch level you actually run
Two different things get confused here: the branch you are on, and whether the build you run includes the current fixes for that branch. You need both before you can plan anything.
To check your own install:
- Run
php -von the server for the command line build. - Check the version the web server uses separately. The CLI and the PHP that answers requests can be different builds.
- Use the application's own report where it has one, such as WordPress Site Health, or your hosting panel's PHP manager.
- Read the package changelog on distribution packages. Distributions backport the fix into the version they shipped rather than moving to a new upstream release, so the upstream number stays the same while the distribution's own package revision changes. Debian explains this in its security FAQ: compare the full package version and changelog against the vendor's advisory, not the upstream number alone.
- Compare what you found against the current releases listed on php.net's supported versions page, which is the authoritative list of upstream branches and their support dates.
- Check who supplies the build. If it comes from a distribution or a paid long-term support vendor, read their published lifecycle policy for the date their maintenance ends, and confirm your PHP package is in scope. That date is not the upstream date.
Write down branch, build, package source and server mode for each property. That single table decides everything after this step.
Choose the target branch on purpose
PHP supports each branch for two years of active support, then two more years of critical security fixes only. These are the upstream dates php.net lists for the current branches, not any vendor's extended schedule.
| Branch | Active support until | Security support until |
|---|---|---|
| 8.2 | December 31, 2024 (ended) | December 31, 2026 |
| 8.3 | December 31, 2025 (ended) | December 31, 2027 |
| 8.4 | December 31, 2026 | December 31, 2028 |
| 8.5 | December 31, 2027 | December 31, 2029 |
Moving from 8.2 to 8.3 buys you one more year of fixes. Moving to 8.4 or 8.5 buys you two or three, for work you are already doing. Unless a framework or extension pins you to a specific branch, pick the newer target and skip the intermediate stop.
Target only a released, supported branch. The PHP project's pre-release builds page describes release candidates as builds for the community to test for regressions, so a candidate is not a production target. Check the supported versions page again on the day you plan the work, because the table moves as new branches arrive.
Build a staging copy before anything changes
Never make the version switch on the live site first. Build a staging copy that matches production closely enough to be a real test:
- Copy the files and a current database dump.
- Match the PHP extensions, the
php.inivalues and the pool or server configuration, not just the version number. - Match how PHP is served. Apache with mod_php and PHP-FPM are different environments, and code can behave differently in each.
- Treat the copy as live customer data. A database dump carries names, addresses and order history, so mask or drop what the test does not need, keep the rest off laptops and shared drives, and delete the copy when the project ends.
- Lock down access to staging. Authentication or an IP allowlist is the real protection, so the copy is never publicly readable. Add
noindexas a backup, and give each person a separate admin account. Arobots.txtdisallow rule is not access control and can stop a crawler from ever seeing thenoindex. - Keep production secrets out of the copy. Use staging API keys, route mail to a test mailbox, and disable live outbound email so a test cannot reach a customer.
- Point payments at the gateway's sandbox or test mode, with test keys and test cards, and aim webhooks at the staging URL so a test order cannot update a live system.
- Confirm you can put the old version back before you start.
If you cannot build staging, that is the first thing to fix. A migration without a rehearsal is an outage with extra steps.
Work through dependencies and removed features
Most migration effort is not PHP itself. It is everything sitting on top of it.
Work outward from the runtime: the framework or CMS version, then plugins, themes and extensions, then your own code and Composer requirements. Check each one against the target branch before you switch.
Update on the old branch where compatibility permits, so each change can be tested on its own before the runtime moves. Some releases that support the target branch require it and cannot be installed while the site still runs the old one. Leave those for the staging copy, apply them together with the version switch there, and note them in the runbook so the production cutover repeats the same sequence.
Then read the official migration guide for each hop you are making, not only the last one. Each guide covers one specific step and lists its backward incompatible changes, deprecated features and removed extensions, and the changes stack:
A move from 8.2 to 8.5 means reading all three. A move from 8.2 to 8.4 means the first two.
Turn deprecation notices into a list rather than noise: log them in staging, group by package, and fix or replace the source. A deprecation is not an outage today, but it is the next migration's work arriving early.
Test the paths that matter
A home page that loads proves very little. Test the paths that take money or move data, with error logging on and displayed errors off:
- Cart, checkout and the payment provider's return and webhook callbacks.
- Login, password reset, registration and admin sessions.
- File uploads and large imports, including the requests your integrations send.
- Scheduled jobs and queue workers, which often run under a different PHP build than the web server.
- Feeds and integrations: accounting, ERP, shipping, email and any partner API.
- Anything that generates a document, such as invoices, labels or exports.
In staging, place a complete order through the payment gateway's sandbox with test cards, and follow it through capture, confirmation email, webhook handling and the admin order screen. Read the logs afterwards, not just the screen. Silent deprecations and warnings during checkout are the ones that become tickets in January.
On production, verify separately. After the switch, place one small order on a live payment method, then void or refund it under your gateway's rules and confirm the reversal appears. Check the email, the webhook and the order record for that live order too, and note it in your books so a verification order is not counted as revenue.
Cut over with a rollback plan
When staging is clean, cut over in a low-traffic window and keep the reversal simple:
- Take a fresh backup of files and database immediately before the switch.
- Deploy the new branch, then restart the PHP workers or the web server so the new interpreter is actually loaded.
- Verify the running build from the application, not only from the command line.
- Watch error logs and failed requests, then repeat the checkout and login checks on production.
- Keep the previous deployment available until you are confident, and write down the exact steps that revert it.
Switching the interpreter back is rarely a complete rollback. By cutover you may also have updated the CMS, plugins and Composer dependencies, changed php.ini or pool settings, and run database migrations. A rollback that works restores a compatible set: the old code and dependency lock file, the old configuration, and a database state the old code can read. Decide before you switch which of those you can reverse in place and which need a restore from the pre-cutover backup, and accept that a restore drops transactions written after it was taken. If a schema change cannot be reversed, write that into the runbook and plan to fix forward instead.
An end-of-life branch on its own is not evidence of a compromise, so do not rotate every secret by reflex. Assess first: review access and error logs for the period the site ran unpatched, check what was reachable from the internet, and list the secrets the application could read. If that review shows actual or plausible exposure, rotate the affected credentials through a coordinated plan so dependent services are updated together.
One caution on interim measures. Hardening configuration and limiting request sizes can reduce exposure while you plan, but they do not replace running a supported branch with current fixes. Use them as a bridge, not as the outcome.
When a migration is not the next step
Not every property needs this project. If you are already on a supported branch and running its current build, your next step is patch discipline and a calendar reminder, not a migration. If you are on a branch past its end of life, the move is overdue rather than upcoming, and it should not wait for the next busy season.
If you would rather have the version and patch state confirmed for you, that is the work Devoptly's PHP audit does: a report per property covering the branch and build, how PHP is served, branch support status, credential exposure, what sits in front of the server and response headers, with the risk and effort stated per item. Published prices are starting points for the smallest scope in each band, and the quote you receive is fixed against the effort in that report. Migration work moves a site to PHP 8.4 or 8.5. It is a version, configuration and exposure audit, not a line-by-line code review or a penetration test.
Whichever route you take, the useful outcome is the same: a written list of what each property runs, a target branch with a support date behind it, and a cutover you have already rehearsed once.
Condensed into a runbook, the whole sequence looks like this:
- ☐ List every PHP property, including subdomains and forgotten campaign sites.
- ☐ Record branch, build, package source and server mode for each one.
- ☐ Check whether a distribution or support vendor extends the upstream date.
- ☐ Choose a released target branch and write down its security support date.
- ☐ Read the official migration guide for every hop, not only the last.
- ☐ Build staging: access locked down, customer data minimized, payments in sandbox.
- ☐ Update dependencies on the old branch where possible, then finish the rest in staging.
- ☐ Test checkout, login, uploads, scheduled jobs and integrations with logging on.
- ☐ Write the rollback for code, dependencies, configuration and database state.
- ☐ Cut over, restart the PHP workers, verify the running build, then place one live order.
- ☐ Review exposure, rotate affected credentials if needed, and set a reminder for the next support date.
