Hono vs Express vs Fastify: 37% Throughput Gap [2026]

Pick any new backend project kicked off in 2026 and there’s a decent chance the first argument isn’t about a database or a cloud vendor. It’s about which server framework to reach for. Express has run the show since 2010, Fastify built a loyal following on raw speed and schema validation, and now Hono has shown up arguing that none of that matters if your code can’t run at the edge. The debate has stopped being academic. With Cloudflare Workers, Deno Deploy, and Vercel’s edge runtime all competing for traffic that used to live on a single Node.js box, the framework you choose now decides where your API is allowed to run at all.

This comparison pulls apart Hono, Express, and Fastify on the numbers that actually matter: requests per second, cold start time, bundle size, TypeScript support, security history, and what each one costs to run once you factor in serverless billing. We tested claims against the official Fastify benchmark suite, cross-checked package health data from Snyk and Open Source Insights, and looked at where each framework is actually deployed in production. The goal is a verdict backed by numbers, not vibes.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What Is Hono, and Why Is Everyone Suddenly Talking About It?

Hono (styled Hono.js in search results, though the project itself just calls it Hono) is a web framework built around Web Standards APIs rather than Node’s older request and response objects. Where Express and Fastify were both written assuming a Node.js server process, Hono was built by maintainer Yusuke Wada to run anywhere that supports the Fetch API: Cloudflare Workers, Deno, Bun, AWS Lambda, Vercel’s edge functions, and, as a fallback, plain Node.js too. That runtime-agnostic design is the entire pitch. You write one router and one set of handlers, and the same code can ship to a Cloudflare Workers deployment on Monday and a traditional Node server on Tuesday without a rewrite.

As of October 2026, the stable Hono line sits at version 4.13.13, with a 5.0.0-rc.1 release candidate published October 10, 2026, following an rc.0 build two days earlier, according to the project’s GitHub releases page. Package trackers disagree sharply on adoption. Snyk’s package page lists Hono at roughly 65.6 million weekly npm downloads, while GitTrend and a separate framework comparison site put the figure closer to 1.2 million a week. The gap is large enough that it likely reflects different counting methods (some trackers appear to fold in re-exports or transitive dependents), so the more conservative figure is the safer one to plan around. GitHub star counts land in a tighter band, with third-party trackers reporting Hono between roughly 30,900 and 32,500 stars as of early-to-mid October 2026.

What makes hono js worth the attention isn’t raw popularity. Express and Fastify both dwarf it on stars and downloads. It’s that Hono is the only one of the three that was designed from day one to run inside a Cloudflare Worker’s V8 isolate, where a traditional Node.js framework simply can’t execute. That single architectural choice is reshaping how teams think about “backend framework” as a category.

The technical reason this matters comes down to isolates versus processes. A Cloudflare Worker, a Deno Deploy function, and a Vercel Edge function all run code inside a V8 isolate, a lightweight sandbox that starts in microseconds but has no access to Node’s filesystem APIs, no long-lived process memory between requests, and no guarantee that a given native module will even load. Express and Fastify were both written on the assumption that a persistent Node.js process is always available underneath them, which is a perfectly reasonable assumption for a traditional server and a hard blocker for an isolate. Hono sidesteps the whole problem by building its router and context object entirely on top of the Fetch API’s Request and Response classes, which exist natively in every one of those runtimes along with Node itself. That’s also why a hono js app that works on Cloudflare Workers today will run unmodified on Bun or Node.js tomorrow, a portability guarantee neither Express nor Fastify can offer.

Express.js in 2026: Still the Default, Still Showing Its Age

Express needs no introduction to most developers, which is exactly the problem framework challengers are trying to solve. First released in 2010 and maintained under the OpenJS Foundation, Express is the framework most bootcamps teach first and the one most legacy Node.js codebases are still built on. Third-party tracking sites report Express at roughly 69,000 to 69,500 GitHub stars and somewhere around 92 million weekly npm downloads as of September and October 2026, figures that dwarf both Fastify and Hono combined.

Express 5 has been the current major line for a while now, with version 5.2.1 showing up as the tested build in Fastify’s own benchmark suite in October 2026. The jump from Express 4 brought native async/await error handling and dropped some long-deprecated methods, but the framework’s core design (a thin wrapper around Node’s built-in http module) hasn’t fundamentally changed. That’s a feature for teams who want stability and a decade of Stack Overflow answers. It’s a liability for teams trying to deploy to an edge runtime, because Express’s reliance on Node-specific request and response objects means it simply doesn’t run on Cloudflare Workers or similar isolates without a heavy compatibility shim.

One real wrinkle worth flagging for anyone running Express alongside Fastify in the same stack: the @fastify/express compatibility plugin, which lets Fastify apps mount Express middleware, has a documented security advisory, GHSA-g6q3-96cp-5r5m, tracked as CVE-2026-22037, covering a URL-encoding and middleware-bypass issue. That CVE sits in the compatibility layer rather than Express core, but it’s a useful reminder that mixing frameworks adds its own attack surface.

Fastify in 2026: The Schema-First Middle Path

Fastify launched in 2016 explicitly to fix what its creators saw as Express’s performance ceiling, and the benchmark numbers below back up that it largely succeeded. Fastify bakes JSON Schema validation and serialization into its core request lifecycle rather than treating it as middleware bolted on after the fact, which is where a lot of its speed advantage over Express comes from. Fastify 5.12.5 was the version tested in the framework’s own October 12, 2026 benchmark run, and third-party comparison pages put the project at approximately 37,000 to 37,200 GitHub stars with weekly npm downloads somewhere in the 5.8 million to 7.5 million range, a tier below Express but comfortably ahead of Hono on raw download counts.

Fastify still runs on Node.js only, unlike Hono. For teams that have no near-term plan to deploy to an edge runtime and just want the fastest possible Node server with strong request validation out of the box, Fastify remains the pragmatic middle path between Express’s familiarity and Hono’s edge-native design. Fastify’s plugin system, built around encapsulated contexts, also gives it a more structured approach to large codebases than Express’s flatter middleware chain, something NestJS has leaned on by offering Fastify as a pluggable HTTP adapter.

Hono vs Express vs Fastify: Full Specs Comparison

The table below lines up the three frameworks across the specs that matter for a real production decision, pulling from GitHub release pages, Fastify’s official benchmark suite, Snyk’s package security data, and Open Source Insights.

Feature	Hono	Express	Fastify
Latest stable version (Oct 2026)	4.13.13 (5.0.0-rc.1 in preview)	5.2.1	5.12.5
First released	2021	2010	2016
Primary maintainer	Yusuke Wada (yusukebe) and community	OpenJS Foundation	Fastify core team
Runtime support	Cloudflare Workers, Deno, Bun, Node.js, AWS Lambda, Vercel Edge	Node.js only	Node.js only (Bun via compatibility layer)
Core API design	Web Standards (Fetch API Request/Response)	Node http module wrapper	Node http module plus schema layer
GitHub stars (approx., Oct 2026)	~30,900–32,500	~69,000–69,500	~37,000–37,200
npm weekly downloads (approx.)	~1.2M (conservative estimate; some trackers report far higher)	~92M	~5.8M–7.5M
Core bundle size	Under 14 KB	Not edge-bundled; relies on Node built-ins	Not edge-bundled; Node-only
Requests/sec (Fastify official benchmark, Node.js)	84,885	62,054	89,258
Latency (same benchmark)	11.30 ms	15.63 ms	10.68 ms
Throughput (same benchmark)	13.92 MB/s	11.07 MB/s	16.00 MB/s
TypeScript integration	Native RPC mode with end-to-end type sharing	Community @types, no built-in RPC	JSON Schema plus TypeBox typing
Request validation	Via Zod, Valibot, or other middleware	Manual or third-party packages	Built-in JSON Schema validation
Known 2026 security note	No core CVE found in current advisories	No core CVE found in current advisories	CVE-2026-22037 in the @fastify/express compatibility plugin
License	MIT	MIT	MIT

A few things jump out immediately. Fastify and Hono are both well ahead of Express on throughput in a like-for-like Node.js test, and the gap between Hono and Express (84,885 versus 62,054 requests per second, a roughly 37% difference) is large enough to matter for any API handling meaningful traffic. But the row that actually decides most architecture conversations in 2026 is runtime support. Only Hono can run natively where Cloudflare Workers, Deno Deploy, and Vercel Edge all expect code to execute, and that single row outweighs a lot of the other comparisons for teams building edge-first products.

Benchmark Results: Requests Per Second and Latency

Framework benchmarks are notoriously easy to game, so it’s worth pulling from more than one source before drawing conclusions. Fastify’s own benchmark suite, last updated October 12, 2026 and run on a single Node.js instance, is the most rigorously documented figure available and the one used in the table above. Fastify itself is explicit that these numbers are illustrative and depend heavily on hardware, Node.js version, and route design, which is a more honest disclaimer than most framework marketing pages offer.

Source	Framework	Reported result	Test conditions
Fastify official benchmarks (fastify.dev)	Fastify 5.12.5	89,258 req/sec, 10.68 ms latency	Single Node.js instance, Oct 12, 2026
Fastify official benchmarks (fastify.dev)	Hono 4.13.13	84,885 req/sec, 11.30 ms latency	Same Node.js instance and test harness
Fastify official benchmarks (fastify.dev)	Express 5.2.1	62,054 req/sec, 15.63 ms latency	Same Node.js instance and test harness
DEV Community benchmark write-up	Hono on Cloudflare Workers	~45,000 req/sec, under 5 ms cold start	Cloudflare Workers runtime, not Node.js
SolGuruz framework comparison	Express / Fastify / Hono (Node.js hello-world)	~14,000 / ~40,000 / ~55,000 req/sec	Independent hello-world test, 2026

The independent figures from DEV Community and SolGuruz don’t line up exactly with Fastify’s own numbers, which is normal. Different hardware, different Node.js versions, and different route complexity all move the needle. What stays consistent across every source checked is the ranking: Fastify and Hono trade the top spot depending on the test, and Express consistently lands last on raw throughput. None of the independent sources tested Express directly against Hono on the same edge runtime, because Express can’t run on Cloudflare Workers without a heavy Node-compatibility shim, which is itself a telling data point.

Cold Starts and Bundle Size on the Edge

Requests per second matters for sustained load, but cold start time decides whether an edge deployment feels instant or sluggish on the very first request after an idle period. This is where the gap between Hono and the other two stops being a performance nuance and becomes a hard architectural limit.

Bundle size: the 14 KB figure that keeps showing up

Multiple independent sources, including JavaScripts.com’s package tracker and several 2026 framework comparison guides, converge on Hono’s core bundle sitting under 14 KB. Estimates for Express and Fastify vary more by source depending on whether they measure core package size, minified output, or gzipped size, but they consistently land well above Hono: figures range from roughly 57 KB to 550 KB for Express and 77 KB to 300 KB for Fastify depending on the measurement method. The honest takeaway is that bundle-size comparisons across these sources aren’t apples to apples, but every single one agrees on the same ordering, with Hono smallest by a wide margin in every version of the comparison.

Cold starts: milliseconds instead of a question mark

Cold start figures for Hono on Cloudflare Workers reported across independent sources range from under 5 ms to 50-100 ms, a spread wide enough that specific numbers should be treated as directional rather than exact. What matters more is the binary fact underneath those numbers: Express and Fastify, built around Node’s http module, don’t run in a Cloudflare Workers isolate at all without a compatibility layer, so “cold start on Workers” isn’t a comparable metric for them in the first place. For teams building serverless or edge-deployed APIs where idle-to-first-byte latency is the user-facing metric that matters, that’s the whole decision in one sentence.

TypeScript and Type Safety: Inside Hono’s RPC Mode

All three frameworks support TypeScript, but they support it at different depths. Express relies on community-maintained @types/express definitions layered on top of a JavaScript-first codebase, which gets you autocomplete but no compile-time guarantee that your client and server agree on a payload shape. Fastify goes further with built-in JSON Schema validation, and pairing it with TypeBox gives you schema-derived types that stay roughly in sync with your runtime validation.

Hono’s official documentation describes a different approach entirely: RPC mode. A Hono server can export its route types directly, and a client built with Hono’s hc helper and parseResponse() function imports those types to get compile-time checking that the request and response shapes actually match what the server defines, without hand-writing a separate client SDK or OpenAPI spec. Third-party write-ups describe this as end-to-end type safety, in the same spirit as tRPC, but built directly into the framework rather than layered on as a separate library. For teams running a single TypeScript monorepo across frontend and backend, this is arguably Hono’s most underrated selling point, ahead of even its edge-runtime story.

Middleware Ecosystem and Plugin Maturity

This is the category where fifteen years of history shows up in Express’s favor and nowhere else. Express’s middleware ecosystem is, by a wide margin, the largest and oldest of the three. Nearly every auth provider, logging tool, and monitoring vendor ships an Express integration as a first-class citizen, and most Fastify plugins exist specifically because an equivalent Express package already proved the concept.

Fastify’s plugin system, built around encapsulated contexts via fastify-plugin, trades some of that raw ecosystem size for more structure. Plugins register in isolated scopes rather than mutating a shared global app object, which scales better on large codebases even if the catalog of ready-made plugins is thinner than Express’s.

Hono’s middleware story is the newest of the three and reflects its edge-first priorities: built-in middleware covers CORS, JWT auth, basic auth, caching headers, compression, and logging, and it ships framework-agnostic adapters for popular validators like Zod and Valibot. What it doesn’t have yet is the deep bench of third-party integrations Express accumulated over a decade and a half. Teams migrating from Express to Hono should expect to write a handful of small adapters themselves for less common integrations rather than finding a drop-in package every time.

Developer Experience and Learning Curve

Raw performance numbers rarely decide which framework a team actually ships with. Day-to-day developer experience does, and the three frameworks land in noticeably different places here. Express’s learning curve is close to flat for anyone who already knows Node.js. The API surface is small, the mental model (middleware functions chained in order, each one calling next()) hasn’t changed in years, and the sheer volume of tutorials, courses, and Stack Overflow threads means almost any error message can be solved with a quick search. That familiarity is exactly why so many bootcamps still teach Express first, even in 2026.

Fastify asks for a bit more upfront investment. Its schema-first approach means developers need to get comfortable writing JSON Schema definitions (or using TypeBox to generate them) before they see the validation and serialization payoff. Teams coming from Express sometimes find this an annoying extra step for simple routes and a genuine productivity boost once an API grows past a handful of endpoints, because the schema doubles as both validation and documentation.

Hono’s learning curve depends entirely on which runtime a developer is targeting. For anyone already comfortable with the Fetch API (which is now standard knowledge for frontend developers, given it’s the same API browsers use), Hono’s context object and routing feel immediately familiar. The friction shows up instead around runtime-specific quirks: debugging a Cloudflare Workers deployment means learning Wrangler’s local dev server and its particular logging and error-reporting behavior, which is a different toolchain than what most Node developers are used to. Teams moving to hono js for the first time should budget a few days to get comfortable with their target runtime’s deployment tooling, separate from learning the framework’s API itself.

Observability, Logging, and Debugging in Production

How easy it is to see what your API is actually doing in production varies sharply across these three, mostly because of the same runtime divide that shapes everything else in this comparison. Express and Fastify both benefit from the full maturity of Node.js’s observability tooling: APM agents from vendors like Datadog, New Relic, and Dynatrace hook directly into Node’s process and event loop, giving detailed flame graphs, memory snapshots, and request traces with minimal setup. Fastify’s structured plugin lifecycle also makes it straightforward to attach logging middleware (commonly Pino, which Fastify uses internally by default) at specific points in the request lifecycle.

Hono running on Node.js gets the same tooling access as Express or Fastify, since it’s still a Node process underneath. Hono running on Cloudflare Workers is a different story entirely. Traditional Node-based APM agents can’t attach to a V8 isolate the way they attach to a long-lived process, so teams running hono js on Workers typically lean on Cloudflare’s own Workers Logs and Workers Analytics Engine instead, or route structured logs to an external log sink. That’s a narrower, newer tooling ecosystem than what Node.js developers are used to, and it’s worth factoring into a migration decision alongside the performance numbers. A framework that’s twice as fast doesn’t help much if an incident at 3 a.m. takes three times longer to diagnose because the debugging tools aren’t as mature yet.

Security Posture: CVEs, Advisories, and Maintenance Health

Security tracking data pulled from Snyk’s package page for Hono and Google’s Open Source Insights dependency tracker shows an actively maintained project with regular releases and no unresolved high-severity advisories against Hono core as of October 2026. The one concrete CVE that surfaced in current research, CVE-2026-22037 (GHSA-g6q3-96cp-5r5m), sits in the @fastify/express compatibility plugin that lets Fastify apps run Express-style middleware, not in Express or Fastify core themselves. It’s a URL-encoding and middleware-bypass issue, a useful reminder that compatibility shims between frameworks are often where vulnerabilities cluster, because they’re forced to reconcile two different security assumptions about how requests get parsed.

Beyond that one advisory, no independently confirmed 2025-2026 core CVE turned up for either Express or Fastify in current research, which should be read as “nothing surfaced in the sources checked” rather than a guarantee of a clean record going back further. Teams running any of these three in production should still subscribe to each project’s security advisory feed directly rather than relying on a single comparison article as their patch-tracking source.

Pricing: What Each Framework Actually Costs to Run

None of these frameworks charge a license fee. All three are MIT-licensed and free to use. The real cost difference shows up in the infrastructure bill once you pick a deployment target, because Hono’s edge-native design opens pricing tiers that Express and Fastify can’t reach without extra infrastructure of their own.

Deployment path	Hono	Express	Fastify
Cloudflare Workers free tier	Supported natively; 100,000 requests/day free	Not supported without a heavy compatibility shim	Not supported without a heavy compatibility shim
Cloudflare Workers paid plan	$5/month base, usage-billed beyond free tier	Not applicable	Not applicable
Traditional Node.js VPS/VM	Runs fine, same hosting cost as any Node app	Baseline hosting cost, no premium	Baseline hosting cost, no premium
AWS Lambda	Supported natively via Hono’s Lambda adapter	Supported via serverless-http or similar wrapper	Supported via aws-lambda-fastify wrapper
Container/Kubernetes deployment	Viable, no particular cost advantage over the others	Standard Node.js container cost	Standard Node.js container cost, often needs fewer instances due to higher throughput

The pattern that matters here isn’t that Hono is cheaper everywhere. On a standard Node.js VPS, all three frameworks cost exactly the same to run because the framework choice doesn’t change the hosting bill. The pricing story only diverges once you move to an edge platform, where Hono can use Cloudflare Workers’ free tier directly and Express or Fastify cannot use it at all without first running inside a Node-compatible container layer, which erases most of the cost savings edge platforms are supposed to offer in the first place. For teams chasing the lowest possible infrastructure bill on low-to-moderate traffic APIs, that’s a real dollar difference, not just an architectural preference.

Real-World Examples: Who’s Actually Running What

Framework comparisons tend to live in the abstract, so it helps to look at how teams are actually deploying each option in production.

• Cloudflare’s own edge services. Independent analysis from a 2026 framework guide points to Cloudflare using Hono internally for services tied to D1, Workers KV, and Workers Logs. This should be read as a reported claim rather than an official Cloudflare statement, but it lines up with the obvious logic of a company building Workers also dogfooding the framework best suited to run inside it.
• Legacy enterprise APIs still on Express. The overwhelming majority of production Node.js APIs still run on Express, simply because they were built years ago and migrating a working system carries real risk. Express’s roughly 92 million weekly downloads reflect this installed base more than new project starts.
• High-throughput internal APIs on Fastify. Teams building internal microservices where request validation and raw throughput both matter, and where there’s no edge-deployment requirement, frequently pick Fastify specifically for its built-in JSON Schema validation layer, which cuts down on hand-written input-checking code.
• NestJS projects swapping in Fastify as the HTTP adapter. NestJS supports both Express and Fastify as pluggable platforms, and teams chasing lower latency on an existing NestJS codebase frequently switch the underlying adapter to Fastify without rewriting their controllers, a migration path that doesn’t exist for Hono.
• New edge-first startups building on Hono from day one. Smaller teams building APIs meant to run close to users globally, particularly ones already using Cloudflare for DNS or CDN, increasingly default to Hono specifically so the API layer and the edge network share the same runtime, cutting out a whole category of “does this even deploy here” questions before they start.

Which Framework Fits Your Use Case

The honest answer to “which one should I use” depends heavily on where the API needs to run and how much existing code you’re carrying forward.

• Building a new edge-deployed API on Cloudflare Workers, Deno Deploy, or Vercel Edge: Hono is close to the only realistic option, since Express and Fastify simply don’t run natively in those environments.
• Maintaining a large, mature Express codebase with dozens of middleware dependencies: Stay on Express. The migration cost of swapping frameworks rarely pays for itself unless you have a specific edge-deployment or performance requirement forcing the issue.
• Building a new Node.js-only API where request validation and throughput both matter: Fastify’s built-in JSON Schema validation and roughly 37% throughput advantage over Express make it the stronger default for greenfield Node projects with no edge requirement.
• Running a TypeScript monorepo where the frontend and backend need to share types: Hono’s RPC mode offers tighter end-to-end type safety than either Express or Fastify provide out of the box, which matters more as monorepos become the default structure for small teams.
• Running a NestJS application and want more raw speed without rewriting controllers: Switch the underlying HTTP adapter to Fastify. NestJS supports this as a configuration change rather than a rewrite.
• Prototyping something quickly with the largest possible pool of Stack Overflow answers and tutorials to lean on: Express remains the easiest framework to get unstuck on, purely because of its fifteen-year head start in documentation and community content.
• Building a serverless function that needs to cold-start in single-digit milliseconds: Hono’s sub-14 KB bundle and Web Standards design give it a real edge here that neither Express nor Fastify can match without architectural changes.

Migration Guide: Moving From Express to Hono or Fastify

Migrating an existing Express app isn’t a single afternoon’s work, but it’s also not the ground-up rewrite many teams assume it will be. Here’s the realistic path for each direction.

Express to Fastify

This is the lower-friction move of the two, because both frameworks share the same Node.js runtime assumptions.

1. Audit your Express middleware stack and check each one against Fastify’s plugin registry or the @fastify/express compatibility layer for anything without a native Fastify equivalent.
2. Convert route handlers from Express’s (req, res, next) signature to Fastify’s (request, reply) signature, which is a mechanical find-and-replace for most simple handlers.
3. Move inline validation logic into Fastify’s JSON Schema definitions on each route, which replaces a lot of manual if statements with declarative schema objects.
4. Replace res.json() and res.send() calls with Fastify’s reply.send(), keeping an eye on Fastify’s automatic JSON serialization behavior.
5. Run your existing test suite against the Fastify version before touching production traffic, and load-test both versions side by side to confirm the expected throughput gain actually shows up on your real routes, not just in a synthetic benchmark.

Express to Hono

This move involves a bigger mental shift, because you’re also deciding where the app will run.

// Express route
app.get('/users/:id', async (req, res) => {
  const user = await getUser(req.params.id)
  res.json(user)
})

// Equivalent Hono route
app.get('/users/:id', async (c) => {
  const user = await getUser(c.req.param('id'))
  return c.json(user)
})

1. Decide your target runtime first (Cloudflare Workers, Node.js, Bun, or Deno), since this determines which Hono adapter you install and whether you need to swap any Node-specific APIs your middleware relies on.
2. Rewrite each route handler around Hono’s single context object (c), replacing the separate request and response objects Express uses.
3. Replace Express middleware package by package with Hono’s built-in equivalents or community adapters for CORS, auth, logging, and compression.
4. If you’re deploying to an edge runtime, remove any Node-specific APIs (direct filesystem access, certain native modules) that won’t exist inside a Workers isolate.
5. Set up Hono’s RPC mode if your frontend is TypeScript, exporting your app’s route types so the client gets compile-time checking against the real API shape.
6. Deploy to a staging environment on your target runtime first. Edge-runtime quirks (different timers, no persistent in-memory state between requests) tend to surface here rather than in local development.

Pros and Cons at a Glance

Hono

• Runs natively on Cloudflare Workers, Deno, Bun, Node.js, Lambda, and Vercel Edge from one codebase
• Core bundle under 14 KB, with cold starts reported in the single-digit milliseconds on Workers by independent testers
• Built-in RPC mode for end-to-end TypeScript type safety between client and server
• Smallest middleware ecosystem of the three, meaning more manual adapter work for less common integrations
• Youngest project (2021 launch), with a smaller long-term production track record than Express or Fastify

Express

• The largest middleware ecosystem and documentation base of any Node.js framework, by a wide margin
• OpenJS Foundation governance and fifteen-plus years of production hardening
• Slowest of the three on throughput in the Fastify benchmark suite, trailing Fastify by roughly 44% and Hono by roughly 37%
• Can’t run natively on Cloudflare Workers or similar edge isolates without a heavy compatibility shim
• No built-in request validation or schema layer, relying entirely on third-party packages

Fastify

• Fastest of the three in the official Fastify Node.js benchmark, at 89,258 requests per second
• Built-in JSON Schema validation and serialization reduce hand-written validation code
• Works as a drop-in HTTP adapter for NestJS applications already built on Express’s API shape
• Node.js only, with no native edge-runtime support
• Smaller middleware catalog than Express, though more structured through its encapsulated plugin system

The Verdict: Our Pick for 2026

There isn’t a single winner here, and that’s actually the useful takeaway. The decision splits cleanly along one line: where does the code need to run? If the answer involves Cloudflare Workers, Deno Deploy, or any edge runtime that isn’t a traditional Node.js process, Hono is close to the only viable option among these three, and its sub-14 KB bundle plus built-in RPC type safety make it a genuinely strong pick rather than a compromise. If the answer is a traditional Node.js server and the project is new, Fastify’s roughly 37-44% throughput advantage over Express, backed by built-in schema validation, makes it the stronger default. And if the answer is “we already have a large Express codebase that works,” the migration cost to either alternative usually isn’t worth paying unless a specific edge-deployment or performance requirement is forcing the decision.

The one trend worth watching into 2027 is how fast Hono’s ecosystem catches up to Express’s middleware depth. Right now that gap is the single biggest practical argument against choosing Hono for a complex application, more than any performance number in this comparison. Everything else points toward edge-native frameworks becoming the default, not the exception.

Frequently Asked Questions

Is Hono faster than Express?
Yes, in the official Fastify benchmark run on Node.js, Hono 4.13.13 reached 84,885 requests per second against 62,054 for Express 5.2.1, a roughly 37% gap. Independent tests report similar rankings, though exact numbers vary by hardware and route complexity.

Can Express run on Cloudflare Workers?
Not natively. Express is built around Node’s http module and request/response objects, which don’t exist inside a Workers isolate. Running Express-style code on Workers requires a heavy Node-compatibility shim, which defeats much of the cold-start and cost advantage Workers is meant to offer.

Is Hono production-ready in 2026?
The stable 4.x line has shipped regular releases for several years, with a 5.0.0 release candidate published October 10, 2026, and no unresolved core security advisories found in current Snyk and Open Source Insights data. It’s younger than Express or Fastify, but it’s actively maintained and used in production by multiple teams, including reported internal use at Cloudflare.

Does Fastify work with NestJS?
Yes. NestJS supports Fastify as an alternative HTTP adapter to its Express default, and teams can switch the underlying adapter without rewriting controller logic, picking up Fastify’s throughput advantage on an existing NestJS codebase.

What is Hono’s RPC mode?
It’s a built-in mechanism for sharing route types between a Hono server and a TypeScript client. Using Hono’s hc client helper and parseResponse() function, a frontend can import the server’s exported route types directly, giving compile-time checking that request and response shapes match, without a separately maintained OpenAPI spec or SDK.

Which framework has the smallest bundle size?
Hono, consistently, across every source checked. Its core sits under 14 KB, while estimates for Express and Fastify range from roughly 57 KB to 550 KB depending on whether the source measures core package size, minified output, or gzipped size.

Is it worth migrating an existing Express app to Hono or Fastify?
Only if you have a specific reason: an edge-deployment requirement that Express can’t meet, or a performance bottleneck that Fastify’s schema-validated routing would solve. For a stable Express app with no such pressure, the migration cost rarely pays for itself.

Does Hono support TypeScript as well as Express or Fastify?
It goes further than either. Express relies on community-maintained type definitions layered on top of JavaScript, and Fastify pairs JSON Schema with TypeBox for schema-derived types. Hono’s RPC mode is built specifically to share types end-to-end between server and client, which neither of the other two offers natively.