If you’re building a REST API in Node.js today, you have more credible options than ever. Express has been the default for over a decade. Fastify arrived promising better performance without sacrificing developer experience. And Hono — the newest of the three — is designed from the ground up for edge runtimes and serverless platforms.

This article breaks down Express, Fastify, and Hono across the dimensions that actually matter when you’re choosing a framework for your next project.

A Quick Introduction

Express (first released in 2010) is the grandfather of Node.js web frameworks. It defined the middleware pattern that nearly every framework since has borrowed. Express 5 finally reached stable in late 2024, but the core philosophy remains the same: minimal, unopinionated, and flexible.

Fastify (first released in 2017) was built specifically to address Express’s performance limitations. It uses a schema-based approach with JSON Schema validation baked in, and its plugin architecture encourages encapsulation over global middleware chains.

Hono (first released in 2022) started as a Cloudflare Workers framework and expanded into a universal web framework. It runs on Deno, Bun, AWS Lambda, Vercel Edge Functions, and plain Node.js — all from the same codebase.

Maturity and Ecosystem

Express is the most mature by a wide margin. With 15+ years of production use, there’s a middleware or guide for virtually anything you need. The npm ecosystem is saturated with Express-compatible packages, and nearly every Node.js tutorial assumes Express.

Fastify has been production-ready since 2018 and is used by companies like Microsoft, Nearform, and others at scale. Its plugin ecosystem is smaller than Express’s but growing steadily, and many Express middleware packages can be adapted via @fastify/express or @fastify/middie.

Hono is the youngest but has gained traction remarkably fast. Its ecosystem is smaller, though it ships with built-in middleware for common needs like CORS, JWT, Bearer auth, ETag, and more. The trade-off: you’re less likely to find a random npm package that “just works” with Hono compared to Express.

Performance

Performance benchmarks always come with caveats, but the relative ordering is consistent across independent tests. Here are approximate numbers for a simple JSON response on Node.js 22 (single core, no clustering):

Framework	Requests/sec (approx.)	Latency (avg)
Express 5	~15,000	~6.5 ms
Fastify 5	~55,000	~1.8 ms
Hono 4	~45,000	~2.2 ms

Fastify’s speed comes from its internal radix-tree router, schema-based serialization with fast-json-stringify, and careful avoidance of unnecessary allocations. Hono uses a RegExpRouter and a lightweight request/response model based on Web Standards (Request/Response), which keeps overhead low.

Express’s callback-based architecture and lack of built-in schema serialization make it the slowest of the three. For many applications this doesn’t matter — your database query takes 50ms regardless — but at high concurrency, the gap becomes real.

TypeScript Support

TypeScript has become the standard for serious Node.js projects, so framework-level support matters.

Express was written in JavaScript. Community-maintained @types/express typings exist, but they’re imperfect. Request/response generics are awkward, and middleware typing often requires manual casting. Express 5 improved things slightly but didn’t rewrite the core in TypeScript.

Fastify has shipped its own TypeScript declarations since v3. Its generic-based approach lets you type route params, querystrings, body, and headers via JSON Schema inference. The DX is solid, though the generics can get verbose for complex routes.

Hono is written in TypeScript from the ground up. Its type inference is arguably the best of the three — route parameters, middleware context, and validation results flow through the type system automatically. If TypeScript DX is a priority, Hono has a clear edge.

Middleware and Plugins

Express popularized the (req, res, next) middleware pattern. The sheer volume of available middleware is its biggest advantage. Need rate limiting, session management, or CSRF protection? There’s a well-tested package for it.

Fastify uses an encapsulated plugin system instead of a linear middleware chain. Plugins can register routes, decorators, and hooks within a scoped context, which prevents the “middleware order matters” bugs that plague large Express apps. The ecosystem includes official plugins for Swagger/OpenAPI, multipart, CORS, helmet, and more.

Hono uses a middleware pattern similar to Koa’s async/await style. It ships with a solid set of built-in middleware and supports custom middleware easily. The key difference: Hono middleware works with the Web Standard Request/Response API, so middleware you write for Hono is portable across runtimes.

Edge and Serverless Support

This is where Hono separates itself from the pack.

Express was designed for long-running Node.js servers. Running it in serverless environments (Lambda, Cloud Functions) requires adapters like serverless-http, and it doesn’t run on edge runtimes like Cloudflare Workers or Deno Deploy at all.

Fastify works in serverless with adapters (@fastify/aws-lambda), but its startup time — while fast for a Node.js framework — is heavier than what edge runtimes prefer. It’s not designed for Workers-style environments.

Hono was born on the edge. It uses Web Standard APIs (Request, Response, fetch) as its foundation, which means the same application code runs on:

• Cloudflare Workers / Pages
• Deno and Deno Deploy
• Bun
• AWS Lambda (via adapter)
• Vercel Edge Functions
• Node.js (via @hono/node-server)

If you’re building for multiple runtimes or want to deploy the same API to the edge, Hono is the only framework here that treats this as a first-class concern.

Learning Curve

Express has the gentlest learning curve. The API surface is small, documentation is extensive, and there are thousands of tutorials, courses, and Stack Overflow answers. A beginner can have a working API in minutes.

Fastify is slightly more complex upfront. The plugin system, schema validation, and lifecycle hooks take time to learn, but they pay off in larger applications. Developers coming from Express will need to adjust their mental model.

Hono is easy to pick up if you’re familiar with modern JavaScript and Web APIs. The API is clean and minimal. The learning curve steepens when you start working with multi-runtime deployment or advanced type inference, but the basics are straightforward.

Side-by-Side Comparison

Feature	Express 5	Fastify 5	Hono 4
First Release	2010	2017	2022
Performance (req/s)	~15k	~55k	~45k
TypeScript	Community types	Built-in declarations	Written in TS
Middleware Ecosystem	Massive	Large (growing)	Moderate (built-ins)
Edge Runtime Support	None	Limited	First-class
Serverless Support	Via adapter	Via adapter	Native + adapters
Schema Validation	External (Joi, Zod)	Built-in (JSON Schema)	Built-in (Zod adapter)
Learning Curve	Low	Medium	Low–Medium
OpenAPI Generation	External	Official plugin	Built-in (Zod OpenAPI)
Multi-Runtime	Node.js only	Node.js only	Node, Deno, Bun, Edge

When to Pick Each

Pick Express when:

• You’re building a quick prototype or learning Node.js for the first time
• Your team already knows Express and the project doesn’t have extreme performance requirements
• You need a specific middleware that only exists for Express
• You’re maintaining an existing Express codebase

Pick Fastify when:

• Performance matters and you’re running on Node.js
• You want built-in schema validation and serialization
• You’re building a large API where encapsulated plugins prevent architectural rot
• You need automatic OpenAPI/Swagger documentation from your route schemas

Pick Hono when:

• You’re deploying to edge runtimes (Cloudflare Workers, Deno Deploy, Vercel Edge)
• You want one codebase that runs across multiple runtimes including Bun
• TypeScript developer experience is a top priority
• You’re building a serverless API and want minimal cold-start overhead

The Bottom Line

There’s no single “best” framework — only the best fit for your constraints. Express is safe and familiar. Fastify is the performance king on Node.js with the best schema-driven workflow. Hono is the future-facing choice if you care about runtime portability and edge deployment.

If you’re starting a new project in 2026 with no legacy constraints, try Fastify for traditional Node.js servers and Hono for anything touching the edge. Express remains a fine choice, but the other two have caught up in ecosystem maturity while offering meaningfully better performance and developer experience.