Opening
Express has been the default Node.js framework for over 15 years. If you’ve built a REST API in Node, chances are you started with Express. It’s simple, flexible, and backed by the largest middleware ecosystem in the Node.js world.
Fastify is the faster alternative. Built from the ground up for performance, Fastify uses a radix-tree router and fast-json-stringify to deliver throughput that leaves Express behind. With both Express 5 and Fastify 5 now stable, 2026 is a good time to compare them head-to-head.
This guide breaks down the differences across performance, architecture, validation, and developer experience so you can pick the right tool for your next project.
Quick Comparison
| Feature | Express | Fastify |
|---|---|---|
| Current stable version | 5.x | 5.x |
| Performance (req/s) | ~15,000 | ~55,000 |
| Router algorithm | Linear search | Radix tree |
| Serialization | JSON.stringify | fast-json-stringify |
| TypeScript support | Community @types | First-class built-in |
| Validation | External (Joi, Zod, etc.) | Built-in JSON Schema |
| Plugin architecture | Global middleware chain | Encapsulated plugins |
| Ecosystem size | Massive (15+ years) | Growing rapidly |
| Learning curve | Very low | Low |
| Logging | External (morgan, winston) | Built-in (pino) |
| HTTP/2 support | Requires extra setup | Native support |
| Hooks/Lifecycle | Limited (middleware) | Full request lifecycle hooks |
Performance
Fastify is 3–4x faster than Express in raw throughput benchmarks. In typical hello-world tests, Fastify handles around 55,000 requests per second compared to Express’s roughly 15,000 req/s on the same hardware.
This gap comes from two architectural decisions:
-
Radix-tree router — Fastify’s find-my-route uses a radix tree (prefix tree) that resolves routes in near-constant time regardless of how many routes you register. Express uses a linear scan through route layers.
-
fast-json-stringify — Instead of calling
JSON.stringifyat runtime, Fastify compiles a serialization function from your JSON Schema ahead of time. This avoids the overhead of type-checking every property on every response.
For real-world APIs with database calls and I/O, the gap narrows but remains significant — typically 2–3x in production workloads. If you’re running on resource-constrained environments or handling high concurrency, this difference translates directly into fewer servers and lower costs.
If you’re also evaluating runtimes, see our Bun vs Node comparison — pairing Fastify with Bun can push throughput even higher.
Plugin System
This is where the frameworks diverge most in philosophy.
Express uses global middleware. When you call app.use(), that middleware runs for every request (or every request matching a path). Middleware order matters, and there’s no built-in isolation between different parts of your app. A poorly written middleware can leak state or affect unrelated routes.
// Express — middleware is global
app.use(cors());
app.use(helmet());
app.use('/api', authMiddleware); // affects all /api routesFastify uses encapsulated plugins. Each plugin gets its own context. Decorators and hooks registered inside a plugin don’t leak to sibling plugins. This makes large applications easier to reason about and test in isolation.
// Fastify — plugins are encapsulated
fastify.register(async function userRoutes(instance) {
instance.addHook('onRequest', authenticate);
instance.get('/users', getUsers);
});
fastify.register(async function publicRoutes(instance) {
// no auth hook here — it's isolated
instance.get('/health', getHealth);
});Fastify’s encapsulation model scales better for large teams and microservice architectures where you want clear boundaries between modules.
Validation
Express has no built-in request validation. You need to add middleware like Joi, Zod, express-validator, or celebrate. This means extra dependencies, extra configuration, and validation logic that lives separately from your route definitions.
Fastify ships with JSON Schema validation out of the box. You define your schema inline with the route, and Fastify validates request body, params, query, and headers automatically — returning a 400 with structured errors if validation fails.
// Fastify — built-in validation via JSON Schema
fastify.post('/users', {
schema: {
body: {
type: 'object',
required: ['email', 'name'],
properties: {
email: { type: 'string', format: 'email' },
name: { type: 'string', minLength: 1 }
}
}
}
}, handler);The same schema also drives serialization (via fast-json-stringify) and auto-generates Swagger/OpenAPI docs with the right plugin. One schema definition handles validation, serialization, and documentation — a significant reduction in boilerplate.
For TypeScript users, Fastify can infer request types from JSON Schema using libraries like @sinclair/typebox, giving you end-to-end type safety from schema to handler.
When to Use Express
- Prototypes and MVPs — Express gets you from zero to running server in minutes with minimal boilerplate.
- Legacy codebases — If your app already runs on Express, migrating has a cost. Express 5 brings improvements without a rewrite.
- Specific middleware needs — Some niche middleware only exists for Express (passport strategies, certain auth providers).
- Learning Node.js — Most tutorials, courses, and Stack Overflow answers use Express. The learning resources are unmatched.
- Teams with Express experience — Familiarity reduces onboarding time and bugs.
When to Use Fastify
- Performance-critical APIs — When throughput and latency matter, Fastify’s 3–4x advantage is hard to ignore.
- Large applications — Encapsulated plugins keep complexity manageable as your codebase grows.
- TypeScript-first projects — First-class types without community @types packages.
- APIs that need validation — Built-in JSON Schema validation eliminates extra dependencies.
- New greenfield projects — No legacy constraints means you can pick the better architecture.
- Microservices — Plugin encapsulation maps naturally to service boundaries.
Verdict
For new projects in 2026, Fastify is the stronger default. It’s faster, has better architecture for scaling, includes validation and serialization out of the box, and offers first-class TypeScript support. The ecosystem has matured enough that most common needs are covered.
Express remains a solid choice when you need its massive middleware library, when your team already knows it well, or when you’re building a quick prototype where raw performance isn’t the priority.
If you’re evaluating more options beyond these two, check out our Express vs Fastify vs Hono comparison for a three-way breakdown including the newer lightweight contender.
FAQ
Is Fastify faster than Express?
Yes, Fastify is 3–4x faster than Express in throughput benchmarks, handling around 55,000 requests per second compared to Express’s ~15,000. This comes from its radix-tree router and ahead-of-time JSON serialization via fast-json-stringify.
Should I switch from Express to Fastify?
If your Express app is working well and performance isn’t a bottleneck, there’s no urgent reason to migrate. However, for new projects or performance-critical services, Fastify’s speed, built-in validation, and encapsulated plugin system make it the stronger choice.
Does Fastify support Express middleware?
Not directly — Fastify uses a different plugin architecture. However, the @fastify/express compatibility plugin lets you use Express middleware inside Fastify, making gradual migration possible without rewriting all your middleware at once.
Is Express dead?
No, Express is not dead. Express 5 is now stable, and it remains the most widely used Node.js framework with the largest middleware ecosystem. It’s still a solid choice, especially for teams with existing Express expertise and codebases.