Updating PHP on a WordPress site with custom plugins needs an application test plan, not just a different setting in the hosting panel. The custom booking rule, export or CRM connector may have no public compatibility badge and no vendor preparing the next release. Before changing the runtime, establish who owns that code, which business actions depend on it and what result must stay the same.
The useful question is not simply “does WordPress support this PHP version?” It is “does this installation, with these dependencies and these business rules, work on the proposed environment?” This guide provides an inventory and release checklist, plus an original experiment showing how an apparently successful adaptation can silently lose data.
Choose a destination for the whole application
Record the current PHP version and proposed destination, including the hosting configuration and required extensions. Check the support position of WordPress, the theme, commercial plugins and custom packages. A provider confirming that PHP is available is not confirming that your bespoke integration works on it. Ask who will investigate any incompatibility found before the switch.
Use the official PHP support calendar when planning. Checked on 25 October 2026, it lists PHP 8.2 security support ending on 31 December 2026. A 2027 plan therefore needs a destination decision, rather than leaving a temporary version pin indefinitely. This does not make any one newer branch compatible with every WordPress installation.
If an update has already broken a feature, the WordPress plugin update repair service covers assessment and recovery. Stabilising an incident and planning a runtime upgrade are related tasks with different acceptance conditions.
Inventory the custom code people forget about
Start with the visible custom plugins, then look beyond the normal plugin screen. Include must-use plugins, child-theme functions, managed snippets, deployment packages and scripts started by scheduled jobs. A small connector can matter more to the business than a large visual plugin. Record its purpose and maintainer alongside its file location.
| Component | Evidence to collect | Decision owner |
|---|---|---|
| Custom plugin | Exact release or commit, purpose and tested entry points | Developer maintaining the source |
| Theme and snippets | Child-theme changes and enabled snippet versions | Person responsible for the site build |
| Bundled libraries | Recorded dependency versions and build artifact | Package or deployment maintainer |
| Runtime | Web and command-line PHP, extensions and relevant settings | Hosting or infrastructure team |
| External integration | API contract, test destination and retry behaviour | Integration owner and receiving team |
| Background task | Schedule, execution context and completion evidence | Person accepting the resulting business action |
“Custom plugin, version unknown” is a finding to resolve. Preserve the installed source before anyone overwrites it and establish whether it matches the maintained repository. If the original developer is unavailable, agree who can assess and own the code. That ownership question should appear in the estimate, not emerge after the hosting deadline.
Write down the behaviour before adapting the code
Choose representative inputs and expected outputs for each affected feature. An export may need to preserve identifiers, zero quantities and accented names. A form may need to reach a specific destination. A scheduled task may need to finish once without duplicating its external action. These are requirements to confirm with the business, not assumptions the developer should invent.
Keep a known-good example from the current environment where available, with its date and versions. If that environment is already failing or unavailable, state which expectations come from an agreed specification. Do not describe a newly written test as proof of historical behaviour that nobody observed.
The plugin-conflict diagnosis guide helps separate component interactions from a runtime issue. The undefined-function guide covers missing providers and load order; a function name in an error still needs investigation before a migration decision.
Combine source review with execution tests
A source scan can identify suspicious constructs and incompatible APIs. Syntax checking can establish whether a particular file parses under a particular interpreter. Neither executes the complete business journey. Record the tool, rules and target version used, review findings and keep unresolved items visible rather than calling every scan result a confirmed defect.
WordPress VIP’s preparation guidance combines scanning and tests with subsequent checks in a non-production environment. Its hosting-specific steps belong to VIP, but the distinction is useful elsewhere: reviewing custom code and exercising the application are separate pieces of evidence.
Check the relevant PHP migration notes for the version transition actually proposed. A long jump may cross several changes. Separate required corrections from unrelated refactoring so that a failed acceptance test has a smaller, understandable set of possible causes.
Our experiment: an export can finish and still be wrong
On 25 October 2026 we ran seven isolated checks using the installed PHP 8.3.36 CLI. No WordPress instance was loaded and no PHP version was changed. Three small fixture files modelled a legacy helper, an adapted helper and a deliberately inadequate adaptation. This is one-runtime laboratory evidence, not a comparison between old and new interpreters or an audit of a customer plugin.
The legacy helper calls each(). The PHP 8.0 migration notes document that function’s removal. Our explicit sample requirement was to process the entire input array, keeping its keys and values, including zero and false. The adapted helper uses foreach; the inadequate variant filters the array first.
| Check | Observed result | What it establishes |
|---|---|---|
| P01 · Legacy syntax | Exit 0; syntax accepted | Parsing did not exercise the removed function |
| P02 · Legacy execution | Exit 255; undefined function each() | The helper could not run on this interpreter |
| P03 · Adapted syntax | Exit 0; syntax accepted | The changed helper parsed |
| P04 · Zero and false | Exit 0; A:2, B:0, C:false retained | The stated sample output matched |
| P05 · Empty input | Exit 0; empty array returned | The agreed empty case passed |
| P06 · Accented text | Exit 0; Peça-01, Àmbit and SKU-X:0 retained | The exact Unicode sample matched |
| P07 · Filtered control | Exit 0; only A:2 retained | No process error, but the business requirement failed |
The last row is why acceptance needs expected data, not just a green process status. In the fixture, array_filter() without a callback removed the zero and false entries. That is an intentional negative control, not a finding about a real export. A zero can be meaningful; whether it should be kept is a requirement to settle before changing an application.
Nor is replacing every each() with foreach a universal migration. The foreach reference explains its iteration behaviour, including the internal array pointer. Our sample contract concerns the complete array and makes no claim to preserve legacy pointer side effects. Real callers may depend on different behaviour.
Reproduce the environment that actually runs the feature
A staging copy should represent the relevant plugin versions, source build, PHP extensions and settings. Identify differences from production. A command-line task can use a different interpreter or configuration from the web requests; record both rather than relying on one control-panel label. A homepage load does not establish that a scheduled export uses the intended runtime.
Agree how staging handles email, payments and integrations before exercising them. Use appropriate test destinations and controlled records so that validation does not accidentally contact customers or create real transactions. Where an external service cannot be tested, document that limitation and assign its acceptance separately.
Our experiment did not test HTTP, a database, WordPress hooks, an external export, browser sessions or a deployment. The real project needs those relevant contexts added to its matrix. The fixture provides an example of a useful question; it does not answer every compatibility question for your site.
Decide what permits the switch and what stops it
| Gate | Evidence needed | If incomplete |
|---|---|---|
| Custom code | Reviewed findings and agreed behavioural checks | Assign correction or accepted limitation |
| Critical journey | Expected result and destination in the target test environment | Do not declare that journey verified |
| Runtime configuration | Confirmed web and background execution contexts | Resolve the environment mismatch |
| Recovery | Available runtime route, preserved files/data and restore procedure | Agree a workable recovery method before switching |
| Ownership | Decision maker, observation window and incident contact | Assign responsibility and timing |
Define stop conditions around actual business impact: a required task fails, records disappear, a receiving system rejects the output or a critical route becomes unavailable. Agree who can halt the release and which evidence they need. Avoid a generic “monitor for a while” instruction with no person, journey or observation period attached.
A rollback plan includes data, not only the PHP selector
Confirm with the host whether the previous runtime remains available and under what conditions. Preserve the relevant code and configuration. If plugin updates also migrated data, changing PHP back does not reverse that migration. An old database restoration can remove newer orders, submissions or account changes, so its implications need a separate decision.
A backup being listed is not the same as a restore procedure being exercised. Record what has actually been checked. If the current source and data must be retained while an incompatibility is corrected, put that into the recovery plan. The post-update outage checklist covers immediate incident triage.
Decide whether to adapt, replace or retire the custom plugin
Adapting can make sense when the feature is still needed, its source is available and someone can maintain the corrected version. Ask for the specific incompatibility and the smallest supported correction. A package that merely becomes quiet after hiding warnings has not demonstrated that it still performs its job.
Replacement deserves its own scope. Compare the business rules, stored data, identifiers, permissions and integration behaviour that the current component supplies. A new plugin with a similar name may omit the exceptional pricing rule or export field that motivated the original development. Include transition and acceptance work in the estimate, rather than comparing purchase prices alone.
Retiring code is another possibility when the business no longer uses the feature. Confirm that decision with its owner and identify any scheduled tasks, dependent components or historical records that must remain available. Removing an apparently inactive plugin does not by itself establish that no background process needs it.
If maintaining a fork of third-party code is proposed, ask who will review upstream changes and keep that fork current. The useful decision is not “old versus new”; it is which option retains the required behaviour with a clear maintenance path. Write the chosen option and its exclusions into the release brief so the hosting change does not quietly become an unapproved application replacement.
What to ask for in the estimate and handover
Ask the proposal to distinguish inventory, compatibility review, code corrections, application tests, deployment and post-switch observation. Clarify whether third-party dependencies, replacement of abandoned code and external integrations are included. The amount of work follows the actual source and features; a fixed “change PHP” task may cover much less than the business expects.
Request the target configuration, changed release or commit, passed and untested journeys, recovery route and future maintainer in the final handover. The WordPress repair report template for 2027 provides a structure for that record. Keep any current limitation separate from an accepted completed check.
To assess the work, send the website URL, current and proposed PHP versions if known, custom-plugin purpose, affected journeys and hosting deadline. The recovery process explains scope and verification. Request a WordPress compatibility assessment before commissioning the switch; the first brief can describe the problem without passwords or an unreviewed code dump.
From a test plan to an implementation brief
If your team needs someone to investigate or adapt the code, use the custom plugin and PHP repair brief to define source availability, affected business rules and the first reviewable stage. Separate containing a current incident from implementing and testing a compatibility change. The proposal should identify the component to change, the maintained source and the evidence needed to accept the result.