Express vs Hapi vs Hono vs Koa: Architecture, Middleware, and Runtime Compared

When building backend services in the Node.js ecosystem, choosing the right framework shapes your entire development experience. express, hapi, hono, and koa all handle HTTP requests, but they solve routing, middleware, and error handling in fundamentally different ways. Let's break down how they tackle common engineering challenges.

🛣️ Routing and Handler Definitions

express uses a simple, imperative approach where you attach methods directly to the app instance.

• Routes are defined by HTTP verb and path.
• Handlers receive req and res objects explicitly.

// express: Imperative routing
const express = require('express');
const app = express();

app.get('/users/:id', (req, res) => {
  res.json({ id: req.params.id });
});

hapi relies on a configuration object to define routes.

• You define routes in an array and pass them to the server.
• This separates route logic from server setup, which helps in large teams.

// hapi: Configuration-based routing
const server = Hapi.server({ port: 3000 });

server.route({
  method: 'GET',
  path: '/users/{id}',
  handler: (request, h) => {
    return { id: request.params.id };
  }
});

hono uses a chainable API that feels similar to Express but is optimized for speed and edge runtimes.

• It supports typed routing when used with TypeScript.
• Handlers return responses directly or use context helpers.

// hono: Chainable routing
import { Hono } from 'hono';
const app = new Hono();

app.get('/users/:id', (c) => {
  return c.json({ id: c.req.param('id') });
});

koa also uses a chainable approach but focuses on the context object ctx.

• Routes are attached via middleware functions.
• It does not bundle a router by default; you typically add @koa/router.

// koa: Context-based routing (with @koa/router)
const Koa = require('koa');
const Router = require('@koa/router');
const app = new Koa();
const router = new Router();

router.get('/users/:id', (ctx) => {
  ctx.body = { id: ctx.params.id };
});

app.use(router.routes());

🧩 Middleware and Flow Control

express uses a callback-based middleware system.

• You must call next() to pass control to the next function.
• Mixing async code with next() can lead to tricky bugs if not handled carefully.

// express: Callback middleware
app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next(); // Must call next to continue
});

hapi uses an extension point system (lifecycle methods).

• You register functions at specific points like onRequest or preHandler.
• This is more rigid but prevents accidental order dependencies.

// hapi: Lifecycle extensions
server.ext('onRequest', (request, h) => {
  console.log('Time:', Date.now());
  return h.continue; // Must return continue
});

hono uses a modern middleware stack similar to Koa but lighter.

• It supports async/await natively without needing next() in many cases.
• Middleware can modify the context before passing it on.

// hono: Async middleware
app.use('*', async (c, next) => {
  console.log('Time:', Date.now());
  await next(); // Wait for downstream middleware
});

koa introduced the "async function" middleware pattern.

• You use await next() to yield control, which makes flow look synchronous.
• This eliminates the "callback hell" common in older Express apps.

// koa: Async/await middleware
app.use(async (ctx, next) => {
  console.log('Time:', Date.now());
  await next(); // Yield control cleanly
});

🚨 Error Handling Strategies

express relies on a specific error-handling middleware signature.

• You must define a function with four arguments (err, req, res, next).
• If you miss an argument, Express will not treat it as an error handler.

// express: Special error handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

hapi handles errors via response objects or throwing errors in handlers.

• It has built-in support for returning standardized error responses.
• You can configure global error handlers in the server options.

// hapi: Throw or return error
server.route({
  method: 'GET',
  path: '/error',
  handler: (request, h) => {
    throw new Error('Something broke!'); // Caught by hapi
  }
});

hono uses a centralized error handler that catches thrown exceptions.

• You register an onError handler to format the response.
• It works seamlessly with async/await try/catch blocks.

// hono: Centralized error handler
app.onError((err, c) => {
  console.error(err);
  return c.text('Internal Error', 500);
});

koa handles errors via standard try/catch blocks in async functions.

• Since middleware is async, you can catch errors naturally.
• It also emits an error event on the app instance for unhandled cases.

// koa: Try/catch or app event
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = 500;
    ctx.body = 'Something broke!';
  }
});

☁️ Runtime and Deployment Targets

express is designed primarily for standard Node.js environments.

• It depends on Node's built-in http module.
• Running it on edge runtimes usually requires a compatibility layer or adapter.

// express: Node.js http server
const http = require('http');
const server = http.createServer(app);
server.listen(3000);

hapi also targets standard Node.js servers.

• It is heavy on dependencies and setup, making it less ideal for serverless cold starts.
• Best deployed on long-running containers or traditional VMs.

// hapi: Node.js server start
await server.start();
console.log('Server running on %s', server.info.uri);

hono is runtime agnostic and built for the edge.

• It runs on Cloudflare Workers, Deno, Bun, and Node.js without changes.
• This makes it highly portable across different hosting providers.

// hono: Export for any runtime
export default app;
// Deployed directly to Cloudflare Workers or Bun

koa runs on Node.js but is lighter than Express.

• It does not include a request handler, giving you more control.
• Like Express, it is not natively designed for edge runtimes without adapters.

// koa: Node.js listener
app.listen(3000, () => {
  console.log('Server running');
});

🤝 Similarities: Shared Ground Between Frameworks

While the differences are clear, all four frameworks share core concepts as HTTP servers.

1. 🌐 HTTP Request/Response Cycle

• All handle incoming HTTP requests and send responses.
• Support standard methods like GET, POST, PUT, DELETE.

// All frameworks support basic JSON responses
// express: res.json({ ok: true })
// hapi: return { ok: true }
// hono: return c.json({ ok: true })
// koa: ctx.body = { ok: true }

2. 🔌 Middleware Architecture

• All allow you to intercept requests before they reach the handler.
• Used for logging, authentication, and parsing bodies.

// All support logging middleware
// express: app.use(logger)
// hapi: server.ext('onRequest', logger)
// hono: app.use('*', logger)
// koa: app.use(logger)

3. 🔒 Security Extensions

• All rely on community or built-in packages for security headers.
• Helmet (Express), hapi plugins, Hono built-ins, Koa middleware.

// Example: Setting security headers
// express: app.use(helmet())
// hapi: server.register(require('hapi-helmet'))
// hono: app.use(secureHeaders())
// koa: app.use(koaHelmet())

4. 📦 Ecosystem Support

• All have npm packages for database integration, auth, and validation.
• Express has the largest, Hono is growing fast in edge spaces.

// Example: Database connection
// All can use standard drivers like pg or mongoose
// const db = await mongoose.connect(...)

📊 Summary: Key Similarities

🆚 Summary: Key Differences

💡 The Big Picture

express is the reliable workhorse 🐎—it has been the standard for a decade and has a plugin for everything. Choose it for traditional Node.js APIs where stability and community support matter most.

hapi is the enterprise fortress 🏰—it enforces structure and security through configuration. Choose it for large teams building complex services where consistency and safety are paramount.

hono is the speedster 🏎️—built for the modern web edge. Choose it if you are deploying to Cloudflare Workers, Deno, or need the smallest possible footprint with high performance.

koa is the modern evolution 🧬—it fixes Express's async pain points without changing the mental model too much. Choose it if you want a cleaner codebase than Express but still want to stay within the Node.js ecosystem.

Final Thought: There is no single "best" framework. express wins on ecosystem, hono wins on performance and portability, hapi wins on structure, and koa wins on developer experience for async code. Match the tool to your deployment target and team needs.