Hono and Fastify lead Express by 1.4x on Node 24; Bun adds another 1.6x for Hono

What the benchmark found

A developer publishing as Fabwaseem has posted self-run benchmarks on dev.to comparing Hono, Express 5, Fastify 5 and NestJS 12 on Node.js 24.22.0, Node.js 26.12.0 and Bun 1.4.3. The top-line result: on Node 24, Hono and Fastify are effectively tied, and both deliver roughly 1.4 times the throughput of Express 5. Hono won the plain-JSON workload (73,067 requests per second against 50,744 for Express), while Fastify came out ahead on route parameters and POST bodies. The single biggest performance jump in the whole exercise came from the runtime rather than the framework: the same Hono app gained another 1.6x when moved to Bun, where it reached 118,000 requests per second.

How the tests were run

The author ran everything on an eight-vCPU Intel Xeon VM with 15 GB of RAM, pinning each server to two cores and running the oha 1.16.0 load generator on the remaining six with 64 connections. Framework versions were the latest npm releases as of October 17, 2026: Hono 4.13.13 with @hono/node-server 2.1.5, Express 5.3.0, Fastify 5.12.7, and NestJS 12.1.3 on both its Express and Fastify adapters.

Three workloads were measured: a fixed JSON response, a route-parameter-plus-query route, and a POST endpoint that parses a 907-byte JSON body. Each setup got a fresh server, a four-second warmup and a ten-second measurement window, with the median of three rounds reported; setups with noisy rounds were re-run with five. In total that covered 32 setups and more than 65 million requests at a 100% success rate. The author cautions that absolute numbers depend on hardware, and that the ratios between frameworks are the more meaningful takeaway on other machines.

Results framework by framework

Raw node:http set the ceiling at 78,870 requests per second on the JSON test, and Hono landed within 8% of it. Express 5 was the slowest of the three frameworks but still served about 50,000 requests per second on two cores — the author calculates that as roughly four billion requests a day, and suggests a database will usually saturate long before an Express server does.

Fastify's find-my-way radix router actually beat the author's hand-written node:http router on route parameters (76,746 versus 73,049), because the raw version constructs a URL object per request. Adding response schemas to Fastify, compiled through fast-json-stringify, was worth only about 4% on these small responses; the author argues the real payoff of schemas is validation and documentation rather than speed. On latency, Hono's p99 for the JSON test was 1.50 ms against 2.12 ms for Express, and Fastify's p99 ran 25 to 40% below Express.

One nuance: Hono's lead narrows on POST bodies under Node, because @hono/node-server converts Node's request into a web-standard Request before the handler runs. On Bun, where Request is native, the same Hono app handled 80,749 POST requests per second, 2.2 times its Node figure.

The NestJS and ecosystem picture

NestJS added 21 to 23% overhead on top of whichever engine it ran on: NestJS with Fastify delivered 56,434 JSON requests per second against 71,786 for Fastify alone, and NestJS with Express delivered 38,893 against 50,744 for plain Express. It was also the slowest to start, at 320 to 425 ms to first response, and the heaviest to install at 22.4 MB across 98 packages. For adoption context, the post cites npm downloads for the week of October 6 to 12, 2026: Express at 145 million, Hono at 74 million (partly because other tools bundle it), and Fastify at 15.4 million.

The author's recommendations: Hono for new APIs, especially ones that might target Bun, Cloudflare Workers or another edge runtime; Fastify for Node-only services that want schemas, plugins and the best throughput on realistic routes; Express where a team and its middleware already exist; and NestJS where codebase structure matters more than roughly 20% of throughput — in which case, run it on the Fastify adapter.

Why it matters

Framework debates are usually settled by synthetic bar charts, and this benchmark — with a disclosed method, pinned versions, median-of-multiple-rounds reporting and a 100% success rate — suggests the gap between the leading Node frameworks is smaller than the hype implies. Hono and Fastify are close enough on Node that portability, schema support and ecosystem fit should drive the choice, while the runtime itself (Node versus Bun) is a bigger performance lever than any framework swap. Express, though slowest here, remains far faster than most APIs will ever need, and NestJS's overhead is both modest and partly recoverable through its Fastify adapter. The most useful guidance is the author's own caveat: rewrites should follow profiling evidence, not benchmark charts — including this one.