How to Upgrade to PHP 8 for Better WordPress Performance (Step-by-Step Guide)

Upgrade your WordPress site to PHP 8 and unlock faster performance, better security, and modern features. Learn how to benchmark, troubleshoot, and fine-tune PHP 8 for maximum WordPress speed and compatibility.

You bumped your site to PHP 8 because someone promised it would be faster. Maybe it felt snappier, maybe it felt like nothing changed. The question nobody answers honestly is where the speed actually comes from, and how much you should really expect.

PHP 8 is a genuine engine upgrade over 7.x and worth doing. But the reasons it speeds up a typical WordPress site aren’t the ones the marketing pages give you. Let’s separate the real gains from the hype and be straight about the JIT compiler everyone keeps citing.

Table of Contents

• The Performance Leap: Why PHP 8 Matters for WordPress
• Key PHP 8 Features Benefiting Your WordPress Site
• Benchmarking: Real-World Speed Gains
• Pre-Upgrade Checklist: Ensuring Compatibility
• Troubleshooting Common PHP 8 Upgrade Issues
• Post-Upgrade: Fine-Tuning for Peak Performance
• Conclusion

The Performance Leap: Why PHP 8 Matters for WordPress

WordPress runs on PHP, so the version you run sets the ceiling on how fast your pages get built. PHP 8.0 landed in November 2020 with a rebuilt, better-optimized engine. Those under-the-hood improvements are where most of your everyday speedup comes from, and you get them the moment you upgrade, with zero code changes.

• Faster page builds: PHP 8 runs the same WordPress code with less overhead than 7.4. A real gain, but a modest one, stacked on top of OPcache doing the heavy lifting.
• Stricter, safer code: PHP 8 tightened error handling and type rules, catching sloppy code that used to fail silently. Good for stability, even if some old plugins need attention first.
• Staying supported: PHP 7.4 hit end of life on November 28, 2022, and 8.0 and 8.1 are past their security windows now too. Running a supported 8.x line (8.2 or newer as of this writing) is table stakes.

Key PHP 8 Features Benefiting Your WordPress Site

A few PHP 8 features get named every time performance comes up. Most of them help developers write cleaner code more than they speed up your homepage. Here’s what each one actually does.

1. JIT Compiler

The Just-in-Time compiler is the headline feature and the most misunderstood. JIT compiles hot code paths to machine code and shines on CPU-bound work: math, image processing, simulations. Typical WordPress isn’t that. A normal request spends most of its time waiting on the database and network, not crunching numbers, so JIT barely moves the needle on a standard site. Heavy custom computation, real win. A blog or a shop, don’t expect much.

2. Named Arguments

Named arguments let you pass values by name instead of position, so calls to functions with long parameter lists stay readable. A clarity feature, not a speed one, but it makes customizing WordPress and wiring up APIs less error-prone.

3. Union Types

Union types let a function declare it accepts more than one type. Less manual type-juggling, more robust plugin and theme code. Again, cleaner code, not faster requests.

4. Nullsafe Operator

The nullsafe operator collapses a chain of null checks into one expression. WordPress pulls data from the database and external APIs constantly, and that data is often missing, so this one tidies up real code you’d otherwise write by hand.

5. Match Expressions and Attributes

Match expressions are a sharper, safer alternative to switch statements, and attributes let you attach metadata directly to classes and functions instead of parsing docblocks. Both are quality-of-life wins for developers.

Benchmarking: Real-World Speed Gains

Set your expectations honestly. The famous “PHP got twice as fast” moment was the jump from 5.6 to 7.0 back in 2015. That was enormous. The step from 7.4 to 8.0 is real but far smaller: independent WordPress benchmarks (Kinsta and others) generally put it in the single digits to low double digits on requests per second, and it varies a lot by site, host, and plugin load.

So treat any fixed percentage with suspicion. A page promising a flat 30% from PHP 8 alone is quoting a synthetic CPU benchmark, not a real WordPress page load. The gain is worth taking, it just isn’t a magic multiplier, and most of it comes from the engine plus OPcache, not from JIT.

Pre-Upgrade Checklist: Ensuring Compatibility

Compatibility is its own deep dive, but you can’t measure a speed gain on a site that white-screens, so here’s the short pre-flight before you touch the live PHP version:

• WordPress core: Run 5.6 or later. That release added beta support for PHP 8.0, and anything current is well past it.
• Theme and plugin audit: Check changelogs, confirm PHP 8 support, and scan for issues before you flip anything.
• Staging first: Clone the site to a PHP 8 staging server and click through it. Never test a version bump on production.
• Back up: Full files-and-database backup before the switch. Always.

Example: WP-CLI Command for Compatibility Check

# Use the WP-CLI PHP Compatibility Checker package
wp phpcompat verify --php=8.0.0

Troubleshooting Common PHP 8 Upgrade Issues

If something breaks, it’s almost always PHP 8’s stricter rules surfacing code that was already fragile. The three you’ll actually hit:

1. Deprecated Warnings

A notice like Deprecated: Function x() is deprecated means some code leans on an old function on its way out. Not fatal yet, but update the plugin or swap the function for its modern equivalent before it becomes one.

2. Fatal Errors and Plugin Conflicts

A hard fatal usually traces to one plugin choking on stricter type checks. Read the error log to find the culprit, check for an update, and if it’s abandoned, replace it.

3. TypeErrors

A TypeError means a function got the wrong data type PHP 8 used to shrug off. Confirm what’s being passed in, then fix the value or the function signature so they agree.

Post-Upgrade: Fine-Tuning for Peak Performance

Once you’re on PHP 8, this is where the actual speed lives. The version bump sets the ceiling; these get you closer to it:

• Confirm OPcache is on: The single biggest engine-level lever, and what turns “PHP 8 is faster” into a number you can feel. Most good hosts enable it, but verify.
• Cache the expensive parts: Object caching (Redis or Memcached) and full-page caching cut the database and PHP work that dominates a real request. This dwarfs anything JIT would do for you.
• Profile before you guess: Use Xdebug or Blackfire to find your real bottlenecks, not the ones a blog post assumed you had.

Code Snippet: Admin Notice for PHP Version

<?php
/**
 * Display an admin notice if the server is not running PHP 8.
 */
add_action('admin_notices', function() {
    if (version_compare(PHP_VERSION, '8.0.0', '<')) {
        echo '<div class="notice notice-error">
                <p>This site is not on PHP 8. Please upgrade for improved performance and security.</p>
              </div>';
    }
});

Conclusion

Move to PHP 8. It’s faster than 7.x, it’s the only supported ground left, and the engine gains are free the moment you switch. Just hold the right expectations: the everyday speedup is the rebuilt engine plus OPcache and caching, not the JIT compiler, which mostly sits idle on an I/O-bound WordPress site. Test on staging, then take the real gain that’s there.

If this saved you a bad afternoon, consider buying me a coffee or subscribing to our newsletter for more straight-talk WordPress performance tips.