1,912 versus 393. That number isn’t a soccer score — it’s requests per second in a benchmark that’s making the backend world sit up. A new PHP Swoole benchmark from phpbenchlab.com, published on October 3, 2026, shows that under realistic database latency, PHP 8.5 with the Swoole extension clearly beats both Node.js 22.x and Go 1.24.x. The report was independently confirmed the same day by TheNextGenTechInsider.
For many developers, that’s a surprise. PHP has long been seen as the language for classic websites, while Node.js and Go are viewed as the tools for high-performance, concurrent systems. The new benchmark challenges that assumption — at least for one very specific use case: workloads that wait heavily on database I/O.
Table of Contents
Key Takeaways
- The PHP Swoole benchmark from phpbenchlab.com (October 3, 2026) shows PHP 8.5 with Swoole 6.2.1 at 50ms database latency reaching 1,912 requests/second — clearly ahead of Node.js, Go, Python, and classic PHP-FPM.
- At 200ms latency the lead grows even bigger: PHP with Swoole reaches 495 RPS, Go only 108 RPS, and all other tested stacks sit around 99 RPS.
- The reason is Swoole’s coroutine model: a worker can yield control while waiting on I/O and handle other requests in parallel, while PHP-FPM blocks synchronously.
- This I/O benchmark should not be confused with an earlier, CPU-intensive test from phpbenchlab.com in the same year, where Go clearly dominated on pure compute load.
- Alongside the benchmark release, the PHP Foundation shipped PHP 8.6.0 RC2 after RC1 had to be skipped due to a packaging error — a sign of an active PHP ecosystem.
What the New PHP Swoole Benchmark from phpbenchlab.com Shows
The test was conducted under controlled, realistic conditions. The test environment was an Ubuntu 22.04 server with 4 vCPUs and 8 GB RAM, with MySQL 8.4 as the database engine. To simulate real database wait times, the team used SELECT SLEEP() queries at two latency levels: 50 milliseconds and 200 milliseconds. These values correspond to typical scenarios where a backend is waiting on a slow query, an external microservice, or an overloaded database.
Five setups were compared:
- PHP 8.5 with Swoole 6.2.1 (coroutines, connection pooling)
- Node.js 22.x (connection pool size 20)
- Go 1.24.x (connection pool size 20)
- Python 3.12.x
- Classic PHP-FPM as a reference point for the traditional PHP architecture
This selection is deliberately broad, covering modern event-loop languages (Node.js), compiled concurrent languages (Go), and the classic PHP variant. That’s exactly what makes the PHP Swoole benchmark so relevant for architecture decisions.
PHP Swoole Benchmark in Detail: Results at 50ms and 200ms Latency
The numbers speak for themselves. At a database response time of 50 milliseconds — a fairly ordinary value for a lightly loaded database — the picture looked like this:
| Stack | Requests/Second | P99 Latency |
|---|---|---|
| PHP 8.5 + Swoole | 1,912 | 62 ms |
| Node.js 22.x | 393 | 256 ms |
| Go 1.24.x | 394 | 914 ms |
| Python 3.12.x | 393 | 461 ms |
| PHP-FPM (classic) | 388 | 264 ms |
PHP with Swoole achieves nearly five times the requests per second compared to the other stacks, while also delivering a significantly lower P99 latency. Notably, Go — well known for its concurrency — posted the worst P99 latency of all tested environments at 914 milliseconds.
At a harsher 200-millisecond latency level, roughly representative of a heavily loaded database or a slow external service, the picture sharpens further:
| Stack | Requests/Second | P99 Latency |
|---|---|---|
| PHP 8.5 + Swoole | 495 | 208 ms |
| Go 1.24.x | 108 | 2,001 ms |
| Node.js 22.x | ~99 | not separately reported |
| Python 3.12.x | ~99 | not separately reported |
| PHP-FPM (classic) | ~99 | not separately reported |
Here, PHP with Swoole performs nearly five times better than Go and roughly five times better than all the other stacks. Go’s P99 latency shoots past two seconds, while Swoole holds a stable 208 milliseconds — nearly identical to the actual database response time.
"A single worker can manage multiple concurrent requests as long as it can yield control during I/O wait times," the phpbenchlab.com report’s central explanation for the PHP Swoole benchmark.
Why PHP with Swoole Outperforms Node.js and Go by So Much
The explanation lies in the architecture model. Swoole uses a coroutine-based approach. As soon as a request is waiting on a database response, the coroutine hands control back to the worker process (a so-called “yield”). The worker can use that wait time to process one or more other requests instead of sitting idle. Only once the database responds does the original coroutine resume. If you’re generally weighing PHP against Node.js as a backend technology, you’ll find a deeper comparison in our article PHP vs. Node.js 2026: Hiring Trends and Use Cases Compared.
This model is fundamentally different from classic PHP-FPM, which works synchronously and blocks: a worker process is tied up for the entire duration of a request, including all database wait time. That’s exactly why PHP-FPM lands at a similarly low level to the other synchronous or less efficiently pooling stacks at both latency levels in the benchmark.
PHP 8.5 with Swoole 6.2.1 also uses connection pooling. Database connections are reused instead of being constantly rebuilt, which saves additional latency. Node.js and Go also used a connection pool of size 20 in the test, yet they couldn’t come close to Swoole’s numbers, because their respective concurrency models apparently operate less efficiently under this specific I/O load than Swoole’s coroutine model.
Important: the available sources attribute the results exclusively to the coroutine principle and yield behavior during I/O waits. Further speculation about internal implementation details of the competing languages cannot be derived from the report.
Context: Don’t Confuse This with the CPU Benchmark
A clear distinction is needed here. phpbenchlab.com had already published an earlier, CPU-intensive benchmark in the same year. In that separate test, Go clearly dominated, because it involved pure compute load without significant I/O wait times — a scenario where compiled languages like Go are traditionally stronger.
The current PHP Swoole benchmark from October 3, 2026 is a completely different test: it explicitly measures database I/O latency, not raw compute performance. Both benchmarks answer different questions and shouldn’t be lumped together. Anyone making an architecture decision should check whether their own application is primarily CPU-bound (e.g., image processing, complex calculations) or I/O-bound (e.g., typical web APIs with database access).
PHP Ecosystem in Motion: PHP 8.6.0 RC2 and Active Development
The benchmark lands in a period of significant movement in the PHP ecosystem. The PHP Foundation recently released PHP 8.6.0 RC2, after RC1 had to be skipped due to a packaging error. For developers, that’s a signal: PHP is being actively developed, and mistakes are communicated transparently and fixed quickly instead of being swept under the rug.
This dynamic fits the overall picture painted by the current PHP Swoole benchmark. PHP is no longer just the language for classic, synchronous web applications. With extensions like Swoole, PHP is increasingly positioning itself in the field of high-performance, concurrent backend systems — a space long dominated by Node.js and Go.
What This Means for Backend Developers
For PHP developers facing an architecture decision, the benchmark offers concrete takeaways:
- I/O-intensive APIs (many database queries, external service calls) benefit especially strongly from Swoole’s coroutine model.
- Connection pooling is a key component of the measured performance and should be considered from the start of any Swoole migration.
- Classic PHP-FPM remains sufficient for many standard applications but shows clear limits under high I/O load combined with many concurrent requests.
- Go and Node.js aren’t inherently worse — they simply perform weaker than Swoole in this specific I/O scenario with the chosen pool configurations.
- Before migrating, it’s advisable to run your own test tailored to your actual production load, since benchmark results always depend on the specific test environment.
Conclusion
The PHP Swoole benchmark from phpbenchlab.com, confirmed by TheNextGenTechInsider, delivers a clear and well-documented result: under realistic database I/O latency, PHP 8.5 with Swoole 6.2.1 clearly beats Node.js, Go, and Python, both in requests per second and in P99 latency. The reason lies in the coroutine model, which uses wait time efficiently instead of letting worker processes block.
For backend developers, this means: if you run heavily I/O-bound PHP applications, Swoole is worth serious consideration for higher throughput and lower latency. At the same time, it’s important to keep the distinction from the earlier CPU benchmark in mind and realistically assess your own workload characteristics — I/O-bound or CPU-bound — before making an architecture decision. Running your own production-like test remains the safest next step to verify these numbers for your own application.
