Which Node.js framework is actually faster (and does it matter)?

I spent last month migrating our API from Express to Fastify because someone showed me a benchmark. Spoiler alert: our database queries still take 150ms and nobody noticed the framework "improvement."

Hono: Fast as hell, ecosystem from hell

Hono will make your autocannon benchmarks look amazing. It's legitimately fast - like stupidly fast. But here's what happened when I tried to deploy it on Cloudflare Workers:

The JWT middleware doesn't exist. OAuth? Roll your own. File uploads? Good fucking luck. I spent 3 days implementing basic auth that took 5 minutes with Passport in Express. The Hono documentation is solid, but the ecosystem is tiny compared to Express middleware.

Where Hono actually doesn't suck:

• Serverless functions where cold starts matter
• Edge computing if you like pain and multi-runtime support
• Proxy services that just pass data through
• Deno Deploy and Bun deployments

Where it'll ruin your weekend: Anywhere you need complex middleware that isn't routing or basic HTTP handling.

Express: Slow but unfuckwithable

Express is the Honda Civic of Node.js frameworks. Boring, reliable, and everyone knows how to fix it. Version 5 finally handles async errors automatically - only took them 10 years to figure that out.

I've used Express at three different companies. Every time someone suggests migrating to something "faster," we run profiler and discover our performance problems are:

1. Unindexed database queries (95% of issues)
2. N+1 query problems from our ORM (4% of issues)
3. Framework overhead (1% of issues)

Express's superpower: When you Google "[framework-name] [problem]" at 3am, Express has 500 Stack Overflow answers. Fastify has 3. The Express middleware ecosystem includes Helmet.js, Morgan, and CORS that just work.

Fastify: The sweet spot if you like TypeScript

Fastify is what Express should have been if it was designed in 2020 instead of 2010. I migrated a medium-sized API (40 routes) from Express to Fastify and it took 2 weeks of nights and weekends.

What actually improved:

• TypeScript integration that doesn't make you want to cry
• Schema validation caught 3 bugs before they hit prod
• Memory usage dropped by like 30% or maybe 35% (mattered for our containerized deployment)
• Plugin system made code more modular

What broke:

• Half our middleware needed rewrites
• Custom error handling required rethinking
• Some Express-specific packages don't work with Fastify equivalents

Real talk: The performance difference is noticeable under load, but the real win is better code organization.

Koa: Beautiful code, beautiful pain

Koa has the cleanest async/await patterns I've ever seen. Also has basically no ecosystem. I started a side project with Koa and gave up after spending 4 hours setting up body parsing and routing.

The middleware stack is elegant as hell, but you'll implement everything yourself. What takes 1 hour in Express takes 6 hours in Koa. You'll need koa-static, koa-cors, koa-helmet, and koa-logger for basic functionality.

When framework speed actually matters

Most of the time? It doesn't. I've profiled dozens of slow APIs and the problem is never the framework:

Real performance killers:

• Database queries without indexes (this is 90% of your problems)
• Fetching data in loops instead of batch operations
• Blocking the event loop with CPU-intensive operations
• Memory leaks from event listeners not getting cleaned up

When framework speed matters:

• WebSocket servers handling thousands of connections
• Serverless functions where cold start time affects billing
• Proxy services that just shuffle HTTP requests around
• High-frequency trading APIs (but then you wouldn't use Node.js anyway)

I deployed a Hono app to Cloudflare Workers for a project that needed <10ms response times globally. The deployment broke 3 times - first with Error: Cannot resolve module \"@hono/node-server\" in production, then ReferenceError: Buffer is not defined because Cloudflare Workers don't support Node.js APIs, and finally a fucking TypeError: fetch is not a function because I was running Hono 3.12.0 which has different runtime expectations. The debugging experience was shit, and I spent more on development time than I saved on infrastructure.

Update for 2025: Hono 4.x fixed most edge runtime issues, but now you have Wrangler 3 deployment complexity. Plus Cloudflare Workers pricing changed - you pay per CPU time, not just requests. My simple proxy that used to cost like $4 or $6 a month now costs $47 because of WebAssembly overhead in their runtime. Finance was not happy.

For most apps, optimize your database queries before you worry about framework benchmarks.

Based on the handful of projects I've worked on and watching other teams make the same mistakes, here's how to actually choose without getting analysis paralysis.

Use Express when you want to get shit done

When Express doesn't suck:

• Your team already knows it (retraining costs more than server bills)
• You need to ship fast and don't care about perfect architecture
• You're building a CRUD app that talks to a database
• You want middleware that already exists for everything

Why I still use Express: Last startup I joined had an Express 4 API with 60 endpoints. I suggested upgrading to Express 5 for the async error handling. Migration took 2 hours. Suggesting Fastify would've taken 2 months and broken half our integrations.

Don't use Express if: You're building a high-throughput API that actually needs performance, or you're starting fresh and want modern patterns.

Use Fastify if performance actually matters

When Fastify makes sense:

• You need TypeScript that doesn't suck
• You want schema validation that catches bugs before prod
• Performance matters and you can afford the migration time
• You like plugin architecture instead of middleware chaos

My Fastify experience: Migrated a 40-route API from Express to Fastify over 2 weeks. Performance improved ~3x under load, but the real win was TypeScript integration that didn't make me want to quit programming. The official plugins cover most use cases.

The migration broke: Half our middleware, authentication patterns, and error handling. Fastify 4.x changed the plugin registration API and broke our custom plugins with TypeError: Cannot read properties of undefined (reading 'register'). Plus Express-style req.user doesn't exist - you get request.user instead, which broke our authentication decorators. Took me like 3 hours to find that one. But the end result was cleaner code with better testing.

Skip Fastify if: Your team is deadline-driven and just wants to ship features.

Use Hono if you hate yourself

When Hono might work:

• You're deploying to edge computing platforms
• Cold start time matters for your serverless functions
• You like implementing everything from scratch with web standards
• You enjoy debugging deployment issues at 3am on multiple runtimes

My Hono disaster: Built a simple API for Cloudflare Workers. Deployment broke with Error: Dynamic require of "crypto" is not supported because Node.js crypto doesn't exist in Workers. Then Cannot read properties of undefined (reading 'jwt') because @hono/jwt doesn't work like Express middleware. Spent 2 hours reading docs that don't explain this shit. File uploads? Write your own because there's no Multer equivalent. Database connection pooling? Good luck - Prisma doesn't work and you're stuck with raw SQL.

But when it worked, response times were insanely fast with sub-millisecond latency.

Don't use Hono unless: You have time to build your own ecosystem and really need that edge performance.

Use Koa if you like beautiful code that takes forever

When Koa works:

• You want the cleanest async/await patterns
• You enjoy implementing routing from scratch
• Your team has senior developers who like architectural purity
• You have extra time to set up basic functionality

My Koa experiment: Started a side project with Koa for the elegant middleware patterns. Spent 4 hours setting up body parsing and routing. Gave up and used Express.

Koa's problem: Everything is DIY. What Express gives you for free, you build yourself. You'll need koa-router, koa-bodyparser, koa-static, and koa-logger just to get started.

Stop overthinking your framework choice

Most performance problems aren't the framework:

Actual performance killers (from my experience profiling slow APIs):

1. Database queries without proper indexes
2. N+1 query problems from your ORM
3. Blocking the event loop with CPU work
4. Memory leaks from uncleaned event listeners

When framework performance matters:

• You're handling >10k requests/sec
• Cold start time affects serverless billing
• You're building proxy services with minimal logic

When it doesn't matter:

• Your database queries take 100ms anyway
• You're building CRUD apps
• Team velocity matters more than raw speed

I've seen teams spend months migrating frameworks to get 2x performance, then discover their slow queries were the real problem. Fix your database indexes before you worry about Express vs Fastify.

Just pick one already

The framework that gets your app deployed fastest is the right choice.