Introduction
We test the latest patch releases:WordPress site owners often ask: will upgrading to PHP 8.5 actually make my site faster? After testing pure CPU‑intensive scripts in our first benchmark and exploring JIT in the second, we now put PHP 8.3, 8.4, and 8.5 to the test in a real‑world WordPress environment. Here’s what we found.
- PHP 8.3.30
- PHP 8.4.17
- PHP 8.5.2
All tests are run on an isolated server with identical configuration – no caching plugins, default theme, and a standard MySQL 5.7.44 setup. We measure both single‑request performance (to isolate PHP engine speed) and 10‑concurrent‑request performance (to simulate real‑world traffic).
Test Environment
| Component | Specification |
|---|---|
| CPU | Intel(R) Xeon(R) Platinum 4-core (vCPU) |
| RAM | 8GB ECC |
| OS | Ubuntu 24.04.3 LTS |
| Web Server | Nginx 1.24 |
| PHP Versions | 8.3.30, 8.4.17, 8.5.2 (latest patches) |
| PHP-FPM | Static processes, pm.max_children = 100 |
| OPcache | Enabled, JIT disabled |
| Database | MySQL 5.7.44, InnoDB buffer pool = 1G |
| WordPress Version | 6.9.1 version |
| Theme | Twenty Twenty-Four (default) |
| Test Tool | Apache Bench (ab) |
| Concurrency | 1 (main) and 10 (additional) |
| Total Requests | 1,000 per run (single), 500 per run (10‑concurrency) |
| Warm‑up | 100 requests before each run (results discarded) |
The server was restarted between version tests to clear any caches.
Methodology
- WordPress setup: A fresh WordPress 6.9.1 installation with the default Twenty Twenty‑Four theme. No caching or optimisation plugins were installed.
- Content generation: 100 posts, 500 comments, and 5 pages were generated via WP‑CLI to simulate a typical blog.
- Testing procedure:
- For each PHP version, we performed 5 independent runs with concurrency 1 (1000 requests each) and 3 independent runs with concurrency 10 (500 requests each).
- Before each run, we issued 100 warm‑up requests with the same concurrency level; these results were discarded.
- All requests targeted the WordPress home page (
/), which includes dynamic content and database queries.
- Data extraction: For each run, we recorded
Requests per secondand the secondTime per request(the average across all concurrent requests). - Averaging:
- For concurrency 1, we discarded the highest and lowest values for each PHP version and averaged the remaining three.
- For concurrency 10, we directly averaged the three runs.
Results
Single‑Concurrency (Baseline)
| Test Run | PHP 8.3.30 (req/s / ms) | PHP 8.4.17 (req/s / ms) | PHP 8.5.2 (req/s / ms) |
|---|---|---|---|
| Run 1 | 5.42/184.569 | 5.43/184.190 | 5.42/184.548 |
| Run 2 | 5.42/184.632 | 5.43/184.298 | 5.43/184.131 |
| Run 3 | 5.43/184.116 | 5.43/184.267 | 5.43/184.237 |
| Run 4 | 5.43/184.255 | 5.43/184.277 | 5.43/184.070 |
| Run 5 | 5.42/184.358 | 5.43/184.252 | 5.43/184.237 |
| Average | 5.42 / 184.49 | 5.43 / 184.27 | 5.43 / 184.15 |
Higher req/s and lower response times are better.
10‑Concurrency (Simulated Traffic)
| PHP Version | Avg Requests/sec (10‑c) | Avg Time per Request (ms) (10‑c) |
|---|---|---|
| PHP 8.3.30 | 5.22 | 191.443 |
| PHP 8.4.17 | 5.24 | 190.642 |
| PHP 8.5.2 | 5.20 | 192.299 |
Each value is the average of three runs, 500 requests each, with concurrency level 10. All runs had zero errors.
Analysis：Why PHP Version Barely Matters for WordPress Performance
The results paint a clear picture: for a default WordPress installation serving its home page, the choice of PHP minor version has no material impact on performance.
- Single‑concurrency: All three versions delivered virtually identical throughput (5.42–5.43 req/s) and response times (184–184.5 ms). The tiny differences (less than 0.2%) are well within normal test variation and are not statistically significant.
- 10‑concurrency: Under moderate load, the pattern persists. PHP 8.4.17 shows a very slight edge (5.24 req/s, 190.6 ms), followed closely by 8.3.30 (5.22 req/s, 191.4 ms) and 8.5.2 (5.20 req/s, 192.3 ms). Again, the differences are negligible (less than 1%) and likely due to run‑to‑run variance.
- Why the gap vanished: Unlike our earlier CPU‑intensive benchmarks, WordPress home page requests spend most of their time waiting for database queries, file reads, and template rendering. These I/O operations dwarf the small CPU optimisations between PHP minor versions. Essentially, the bottleneck moved from the PHP engine to the application and database layers.
This does not mean PHP version upgrades are unimportant – they bring security fixes, new features, and long‑term support. But for a typical WordPress site without heavy custom PHP logic, you should not expect a performance boost solely from moving from 8.3 to 8.5.
Should You Upgrade?
- If you’re on PHP 8.3, upgrading to 8.5.2 is safe and recommended for security and features, but don’t expect any noticeable speed improvement on a standard WordPress site.
- If you’re on PHP 8.4, the same applies: upgrade for support reasons, not for performance.
- For sites still on PHP 7.x, the jump to 8.x is transformative – not only for security but also for the significant performance gains we demonstrated in our first benchmark.
Frequently Asked Questions
A: To measure pure PHP execution. In production, adding a page cache would make the differences even smaller, as most requests would be served statically.
A: It’s a common baseline for shared hosting environments; higher concurrency may be tested in a future article.
A: JIT was disabled to focus on PHP version differences. We already benchmarked JIT separately in the previous article, where it showed dramatic gains on CPU‑heavy tasks.
A: WordPress home page requests are I/O‑bound – they wait for database queries and file operations. The PHP execution time is only a small fraction of the total response time, so minor PHP optimisations get drowned out.
A: For a standard WordPress site with database queries and file operations (I/O‑bound), upgrading from PHP 8.3 to 8.5 will not bring noticeable speed improvements. The performance gains between minor versions are negligible (less than 1%) and fall within normal test variation. However, upgrading is still strongly recommended for security patches, bug fixes, and long‑term support. If you’re on PHP 7.x, upgrading to PHP 8.x will deliver significant performance gains (20‑40% in our benchmarks).
Test Scripts (for Reproducibility)
Important: Run these commands only on your own isolated test server. Never load‑test a production site.
# Before each run, we issued 100 warm‑up requests with the same concurrency level
ab -n 100 -c 1 https://phpbenchlab.com:8083/
# Single‑concurrency test (adjust IP and port)
ab -n 1000 -c 1 https://phpbenchlab.com:8083/
# Before each run, we issued 100 warm‑up requests with the same concurrency level
ab -n 100 -c 10 https://phpbenchlab.com:8083/
# 10‑concurrency test
ab -n 500 -c 10 https://phpbenchlab.com:8083/Example Data Extraction
After each run, record:
Requests per second (e.g., 5.42 [#/sec])
Time per request (e.g., 184.49 [ms]) – the second occurrence, labelled (mean, across all concurrent requests)
All raw data and methodology are provided. Reproduce this benchmark on your own hardware to validate results.