Benchmarks

See how Ferron 3 compares to other web servers in terms of performance, stability, and protocol efficiency.

Performance & stability under load

Ferron 3 is designed for predictable, high-performance behavior under real-world web workloads (including TLS, HTTP/2, HTTP/3, connection reuse, and high concurrency) rather than for winning isolated microbenchmarks.

Our benchmarking suite focuses on five key real-world scenarios:

  1. Reverse proxying & load balancing: testing event-loop efficiency and connection pooling up to 9,901 concurrent connections.
  2. Static file serving & Zstd compression: straining CPU and buffer management with dynamic on-the-fly compression.
  3. Cached WordPress (PHP-FPM): evaluating edge-cache lookup speed and payload validation paths.
  4. HTTP/3 (QUIC) throughput: establishing baseline throughput over modern UDP-based transport.
  5. Observability overhead: quantifying the “telemetry tax” of structured JSON logging under sustained load.

The benchmarking tool was run on a laptop with an Intel Core Ultra 7 258V CPU, running Omarchy Quattro (based on Arch Linux) with Linux kernel version 7.1.9-arch1-2 (unless otherwise specified). The server was a desktop PC with an AMD Ryzen 7 8700G CPU running Kubuntu 26.04 with Linux kernel version 7.0.0-14-generic.

The benchmarks were performed over a local network connection (except for cached WordPress, which was done via localhost, as network was the bottleneck). The client was connected via Wi-Fi, while the server was connected via Ethernet.

The benchmarking setup is available at https://github.com/ferronweb/benchmarking.

Key takeaways

  • Rock-solid stability: under extreme concurrency (up to 9,901 connections), Ferron 3 maintained a 100% success rate with zero errors, while other servers like NGINX and HAProxy suffered from high error rates (up to 77.8% and 70.2% respectively), and Traefik crashed due to Out-Of-Memory (OOM) errors (the “server” had 32 GB RAM, and was running a Live USB version of Kubuntu).
  • Small file leader: Ferron 3 outperforms all competitors in small (226B) HTML file throughput, delivering 133,517 req/s (compared to NGINX’s 86,313 req/s and Caddy’s 74,837 req/s).
  • Production-ready HTTP/3: HTTP/3 is fully supported and production-ready in Ferron 3. It delivers exceptional throughput (114,798 req/s), significantly outperforming NGINX’s QUIC implementation.
  • Efficient edge caching: serving cached WordPress pages, Ferron 3 achieves 91,926 req/s, outperforming OpenLiteSpeed (63,730 req/s) and NGINX (60,156 req/s).

1. Reverse proxying & load balancing

This scenario measures event-loop parsing overhead, upstream connection pool efficiency, and routing layer latency under a concurrency sweep from 1 to 9,901 concurrent connections.

Reverse proxy performance

Requests per second when proxying to a "Hello World" Node.js backend cluster (higher is better)

Higher is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the python3 benchmark.py https://192.168.1.62 10000 100 command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: Traefik OOMed at ~6.8K concurrent requests. NGINX and HAProxy experienced high error rates (up to 77.8% and 70.2% respectively) under high concurrency, while Ferron 3 maintained a 100% success rate with zero errors up to 9,901 concurrent connections.

Latency under load (reverse proxy)

Mean response time under high concurrency proxying to a "Hello World" Node.js backend cluster (lower is better)

Lower is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the python3 benchmark.py https://192.168.1.62 10000 100 command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: Traefik OOMed at ~6.8K concurrent requests. NGINX and HAProxy experienced high error rates (up to 77.8% and 70.2% respectively) under high concurrency, while Ferron 3 maintained a 100% success rate with zero errors up to 9,901 concurrent connections.

2. Static file serving & Zstd compression

Stresses CPU and buffer-management efficiency under on-the-fly transport compression (Zstandard level 4 for Ferron, level 3 for others) and raw static file serving.

Static file serving & compression performance

Requests per second across different file sizes and compression modes (higher is better)

Higher is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the h2load -n 500000 -c 100 -t 16 -m 8 command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: During the Apache and NGINX dynamic Zstd runs, h2load logged "Process Request Failures" due to connection drops under load. Ferron 3 achieves peak throughput with zero errors.

3. Cached WordPress (PHP-FPM)

Evaluates edge-cache lookup speed and payload validation paths with zero application-layer fallback.

Cached WordPress performance

Requests per second serving WordPress front page from cache (higher is better)

Higher is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the h2load -n 50000 -c 100 -t 16 -m 4 https://localhost/ command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: Client is the same as the server (Ryzen 7 8700G) for this benchmark. Ferron 3 with LSCache plugin outperforms NGINX and OpenLiteSpeed.

4. HTTP/3 (QUIC) performance

Establishes a baseline for HTTP/3 implementation under controlled conditions. HTTP/3 is fully supported and production-ready in Ferron 3.

HTTP/3 (QUIC) performance

Requests per second serving a 226B static HTML file over HTTP/3 (higher is better)

Higher is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the tquic_client -t 8 --max-concurrent-conns 25 --max-concurrent-requests 25 -d 10 command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: Tested using tquic_client. Ferron 3 delivers exceptional HTTP/3 throughput, significantly outperforming NGINX with QUIC support.

5. Observability overhead ("the telemetry tax")

Quantifies the runtime cost of structured JSON logging under sustained load serving a 226B static HTML file.

Observability overhead performance

Requests per second with structured JSON logging enabled (higher is better)

Higher is better | Benchmarks run on AMD Ryzen 7 8700G, 32GB RAM, with the h2load -n 500000 -c 100 -t 16 -m 8 command | Linux kernel version 7.0.0-14-generic | Benchmarks performed on September 2, 2026

Note: Measures Phase B (Structured JSON logging to /dev/shm). Ferron 3 maintains high throughput even with full structured logging enabled.

Interpreting the results

In practice, differences on the order of 10–20% in synthetic throughput or latency benchmarks often translate to little or no perceptible difference for end users:

  • Browsers are limited by network latency and TLS handshakes.
  • HTTP/2 and HTTP/3 multiplex requests over shared connections.
  • Static assets are typically cached at the server, CDN, or browser level.

For most real-world deployments, stability under load, worst-case response times (for example, 99th percentile response time), and operational simplicity have a greater impact than small throughput differences measured in isolation.