A technical performance evaluation of modern persistent-memory runtimes compared to Node.js, Python, and legacy request-response execution lifecycles.
Adjust workload constraints to observe how persistent memory servers handle concurrency compared to traditional process lifecycles.
Simulates concurrent HTTP clients requesting endpoints simultaneously.
Simulate database serialization, ORM hydration, and locks
Keeps class compilation cached in shared system memory
Modern PHP
8 ms
Node.js
11 ms
Python
18 ms
Legacy FPM
75 ms
To maintain strict parity and eliminate platform bias, all test containers were executed on identical dedicated hardware environments with isolation.
Web performance is rarely limited by CPU alone; modern web workloads are heavily database-bound. To reflect this, our benchmarks simulate an database-bound web endpoint.
Each HTTP request initiates a connection to a local PostgreSQL instance, executes a keyed index scan (`SELECT * FROM users WHERE id = ?`), joins the user profile to fetch settings, and serializes the result payload to JSON.
In traditional PHP (Nginx + FPM), connection pooling is extremely difficult due to the "shared-nothing" lifecycle where the connection is built and destroyed per-request. Modern persistent runtimes like FrankenPHP allow connection pooling and pre-heated models to stay resident in memory, giving modern PHP direct performance parity with compiled runtimes.
All file inclusions, framework routing setups, and DB connections must be reinitialized for every single request.
Framework files, routes, configurations, and database connection pools are resident in memory. Request processing is immediate.
Sloppy framework configurations and package sprawl cost organizations hundreds of developer hours. See how much your team could save by consolidating infrastructure on Modern PHP.
Total Estimated Annual Savings
$46,500
Monthly Infra Savings
$450
Consolidated Node allocation & low RAM footprints.
Monthly Developer Gain
$3,425
Hours saved using a batteries-included ecosystem.
Calculations are based on container consolidation ratios and standardized developer workflows.
Read White PaperWe believe in complete transparency. You can reproduce these measurements inside any Docker-enabled environment. The source code and environment configurations are open source.
# 1. Spin up the modern PHP container fleet
$ docker-compose up -d --build php-frankenphp-worker
# 2. Warm up the OPcache runtime with some initial request hits
$ curl -s http://localhost:8080/api/users/1 > /dev/null
# 3. Execute 30-second benchmark with 4 threads simulating 250 concurrent clients
$ wrk -t4 -c250 -d30s --timeout 2s http://localhost:8080/api/users/1
# Expected output format:
Running 30s test @ http://localhost:8080/api/users/1 4 threads and 250 connections Thread Stats Avg Stdev Max +/- Stdev Latency 8.45ms 2.15ms 18.42ms 74.20% Req/Sec 1.24k 120.40 1.48k 71.50% 148,840 requests in 30.05s, 85.4MB read Requests/sec: 4953.08 Transfer/sec: 2.84MB
Built for Developers, by Developers
Join the movement and discover why modern PHP is the sophisticated choice for elegant, high-scale applications in 2026.
Platform
Reach Us
Santa Cruz, CA 95062
©2026 doPHP.dev
Proudly built with PHP 8.3 (running on 8.5), Laravel 13, and Statamic 6. How it’s built.