Express vs Fastify vs Hono in 2026

Express vs Fastify vs Hono in 2026 comes down to one question: where does your code run? Express still wins for Node-only services that need every npm package and the biggest hiring pool. Fastify wins for raw Node.js throughput with schema validation. Hono wins if you ship to Cloudflare Workers, Bun, Deno, or any edge runtime from a single codebase.

That is the punchline. Now the trade-offs, the real benchmarks, and the 2026 use cases that decide it for you.

The 2026 short answer

If you woke up today and someone asked which framework to start a new Node.js API in, the honest answer depends on three inputs: your team's experience, where the code will run, and how much throughput you actually need.

On a hello-world benchmark, Hono on Node.js hits around 62K req/s. Fastify lands near 15K. Express sits at 8 to 10K. That looks like an obvious case for Hono, until you put a real database behind the route. Then all three converge to 3 to 6K req/s because the framework is no longer the bottleneck.

Which means most teams are not actually picking on raw speed. They are picking on ecosystem, runtime targets, and who they can hire to maintain it.

Where Express still wins in 2026

Express is the framework people love to declare dead every year, and every year it ships another billion downloads. Here is what it actually has going for it in 2026.

Express 5 is stable. Express 5.0 reached stable in 2024 after a long beta. The big change is native async/await error handling, so you no longer need express-async-handler or wrap every route in a try/catch. That single update closed the most common reason teams jumped to Fastify.

Every npm package supports it. Passport strategies, every Stripe webhook tutorial, every legacy auth middleware, every internal-tools example you find on Stack Overflow. If you need to plug in a 6-year-old library written for Node, Express is the path with the fewest surprises.

The hiring pool is enormous. Pick a random backend engineer with five years of Node experience and there is a near-certain chance they have shipped Express in production. Fastify and Hono have growing communities, but the volume of engineers who can pick up an Express codebase on day one and ship is still many times larger.

Security posture is well understood. Tools like helmet, express-rate-limit, and express-session have been hardened over a decade. Auditors know what to look for. CVEs have well-known patches.

The price of all that: it is the slowest of the three, the middleware model is callback-shaped under the hood, and it has no story for non-Node runtimes. If those things matter to your project, keep reading.

Fastify: the throughput pick on Node

Fastify is what you reach for when you want significantly more throughput than Express on Node, you are willing to think about JSON schemas, and you are not deploying to the edge.

The performance comes from three architectural choices. First, request and response JSON schemas via fast-json-stringify, which serializes about 2x faster than JSON.stringify because it knows the shape ahead of time. Second, a plugin system with encapsulated scopes that avoids the synchronous middleware chain Express depends on. Third, hooks instead of middleware, which removes a lot of overhead per request.

In numbers: Fastify handles roughly 15K req/s on a hello-world benchmark vs Express at 8 to 10K. Real workloads with a network DB call narrow the gap, but the schema validation alone catches a class of bugs you would otherwise write tests for.

TypeScript is first-class. Fastify ships its own types, schemas can drive types via libraries like @sinclair/typebox, and the plugin system encourages clean module boundaries. NearForm built it, Microsoft uses it internally, and most large Node shops have at least one Fastify service in production.

What you give up: a smaller ecosystem than Express. Plugins exist for the common cases (CORS, cookies, JWT, Postgres pools), but if you need an obscure middleware, you may have to port it. And like Express, Fastify is Node-only. If you decide later to ship to Cloudflare Workers or Bun, you are rewriting.

Hono: the multi-runtime pick

Hono is the framework that actually changed the conversation. It is built on the Web Standards Fetch API, not Node's http module, which means the same app.ts runs on Node.js, Bun, Deno, Cloudflare Workers, AWS Lambda, Lambda@Edge, Vercel Edge, Netlify, and Fastly Compute. No adapters in your business logic. No rewrite when you decide to move.

The performance is the headline. On a Node.js hello-world bench, Hono is around 62K req/s, roughly 4 to 5x Express and 4x Fastify. That comes from a heavily optimized radix trie router (multiple router implementations actually, including a smart one that pre-compiles routes), an async-native execution model, and a tiny core. The bundle is about 14 to 15KB minified, which matters when you are deploying to Workers where every kilobyte counts toward cold start.

Two features that genuinely change how you build APIs:

• Hono RPC. Define a route, and Hono generates a typed client your frontend can call with full TypeScript inference. No more duplicating zod schemas across client and server. This is closer to tRPC than to Express, but with regular HTTP underneath.
• JSX out of the box. You can return server-rendered HTML directly from a route, useful for HTMX-style apps or for transactional emails.

Hono went from 1K weekly npm downloads in 2022 to roughly 20 million weekly downloads in 2026, which is the steepest framework adoption curve in Node history.

What you give up: ecosystem maturity. There are fewer plugins than Fastify, far fewer than Express. Authentication patterns work but require more glue. Some npm packages (especially those reaching into Node internals) will not work on Workers, so you may end up with two code paths. And the hiring pool, while growing, is still the smallest of the three.

Head-to-head comparison

Factor	Express 5	Fastify	Hono
Hello-world req/s (Node)	~8 to 10K	~15K	~62K
Real-world with DB	~3 to 4.5K	~4 to 6K	~4 to 6K
Runtimes	Node only	Node only	Node, Bun, Deno, Workers, Lambda, Vercel Edge
Bundle size	~200KB+	~150KB	~14KB
TypeScript	Via @types/express	First-class	First-class + RPC types
Ecosystem maturity	Largest	Strong, smaller	Growing fast, narrower
Hiring pool	Largest	Medium	Smaller but rising
Best fit	Legacy compatibility, broad team	High-RPS Node service	Edge / multi-runtime

The honest read: Express loses on speed and runtime flexibility. Fastify loses on ecosystem breadth and edge support. Hono loses on ecosystem maturity and hiring availability. Pick the one whose weaknesses you can absorb.

Real-world numbers: when the gap collapses

The 4x to 8x throughput gap is real, but it shows up on benchmarks that do almost nothing. The moment you add a Postgres query over the network, an external API call, or any I/O the framework cannot optimize away, the response time is dominated by that I/O.

Concrete shape from a typical realistic test (a single SELECT against a managed Postgres in the same region):

• Database query takes 2 to 10ms.
• Framework overhead is well under 1ms for all three.
• End-to-end you see Hono and Fastify around 4 to 6K req/s, Express around 3 to 4.5K.

The gap is still there, but it is now 30 to 50% rather than 4x. For most CRUD APIs, that gap is smaller than the cost of a poorly indexed query. The framework choice still matters for cold-start scenarios on serverless and for compute-bound work like image transforms, but it is rarely the limiting factor in a normal SaaS backend.

If you are picking your stack and arguing about req/s on a spreadsheet, you are probably optimizing the wrong thing. Pick on ecosystem, team experience, and runtime target. If raw throughput in production becomes a real problem, profile first. The same way Bun, Node, and Deno comparisons only matter once your runtime is actually the bottleneck.

When to choose Express

Pick Express in 2026 when:

• Your team has shipped Express before and the project is Node-only.
• You depend on a niche middleware that does not exist for Fastify or Hono.
• You are extending an existing Express codebase and have no compelling reason to rewrite.
• You want the maximum overlap with public tutorials and Stack Overflow answers.
• You are working with someone less senior who needs the most documented framework to onboard quickly.

Express 5 closed the async-error gap, so the strongest historical reason to leave is gone.

When to choose Fastify

Pick Fastify when:

• You are starting a new Node-only API and want significantly higher throughput than Express.
• You want JSON schema validation for requests and responses, with the speed bonus from fast-json-stringify.
• You like encapsulated plugins and clean module boundaries.
• You are building an internal high-RPS service where the framework is in the hot path.
• You do not plan to ship to Cloudflare Workers or any edge runtime.

It is the most "boring tech" of the three new options, in a good way.

When to choose Hono

Pick Hono when:

• You are deploying to Cloudflare Workers, Bun, Deno, or Vercel Edge.
• You want one codebase that runs on Node today and Workers tomorrow with no rewrite.
• You like end-to-end typed RPC between server and client (this often replaces tRPC for new projects).
• You are building globally distributed APIs where edge latency matters.
• You want the smallest bundle for cold-start sensitivity.

If you are building a Next.js 15 app and using server actions, you may not need a separate API framework at all. But when you do, and any part of it is going to the edge, Hono is the path of least resistance.

The third option most teams miss: who writes it

Framework choice is real, but it is small compared to engineer choice. A senior who has shipped two Hono apps to Cloudflare Workers will out-deliver three juniors trying to learn it from docs, on any framework.

This is where most founders trip. They optimize the stack decision for two weeks and the staffing decision for two days. The right framework with the wrong engineer ships nothing. The wrong framework (within reason) with the right engineer ships and iterates.

Cadence is one option for that staffing problem. Every engineer on Cadence is AI-native by default, vetted on Cursor, Claude, and Copilot fluency before they unlock bookings, and our 12,800-engineer pool covers all three frameworks. Pricing is locked: Junior at $500/week for cleanup and hygiene work, Mid at $1,000/week for end-to-end shipping, Senior at $1,500/week for architecture and edge cases, and Lead at $2,000/week for systems design and fractional CTO work. There is a 48-hour free trial, weekly billing, and you can replace the engineer any week. If you are deciding between rolling Express, Fastify, or Hono in your next service, see how Cadence compares to a contractor or recruiter loop before you commit a hire.

If you would rather hire full time, that is a perfectly valid path. The point is to pick the staffing model first, then the framework. Just like the choice between onshore, offshore, or nearshore development, the staffing shape often dictates the technical shape.

What to do next

A practical sequence:

1. List every runtime your code will plausibly run on in the next 18 months. Node only? Edge eventually? Multi-runtime?
2. Map that to the framework. Node only and large team: Express 5 or Fastify. Edge or multi-runtime: Hono.
3. Build a 2-day spike of the riskiest endpoint in your real chosen framework. Measure with your real database, not a hello-world bench.
4. Decide.

If you want a second opinion on the stack choice itself, our Build, Buy, or Book decision tool takes 90 seconds and gives an honest recommendation.

Need an engineer to ship the spike? Cadence shortlists vetted engineers in 2 minutes, with a 48-hour free trial and weekly billing. Every engineer is AI-native by default, so a Mid at $1,000/week can prototype Express, Fastify, and Hono versions in parallel and tell you which one wins on your workload.

FAQ

Is Express still relevant in 2026?

Yes. Express 5 went stable in 2024 with native async error handling, and it remains the most common Node.js framework by a wide margin. For Node-only services with a typical team, it is still a perfectly defensible choice.

Can I switch from Express to Fastify or Hono later?

Yes, but the route handler shape differs. Fastify handlers use request / reply with schema, and Hono uses a Context object built on Fetch. Plan a few days per service if you have middleware-heavy code, more if you depend on Express-only middleware.

Does Hono work on Node.js or only on Cloudflare Workers?

Hono runs unchanged on Node.js via @hono/node-server. The same app.ts ships to Workers, Bun, Deno, Lambda, and Vercel Edge with a runtime adapter, no business-logic changes.

Which framework has the best TypeScript support?

Hono and Fastify both ship first-class TypeScript. Hono goes further with end-to-end type-safe RPC between client and server. Express needs @types/express and the typing is shallower.

What is the fastest Node.js framework in 2026?

On hello-world benchmarks, Hono on Node.js is the fastest at roughly 62K req/s, followed by Fastify around 15K and Express at 8 to 10K. With a real database in the loop, all three converge to 3 to 6K req/s, so framework speed rarely decides the architecture.