Framework Philosophy

Express and Koa represent two different approaches to building web applications in Node.js. Express bundles numerous built-in features like connect and router, providing a more feature-complete solution out of the box. Koa, in contrast, takes a minimalist approach, alowing developers to compose their own framework by selecting only the middleware they need.

Asynchronous Handling

The most significant architectural difference lies in how these frameworks handle asynchronous operations. Express relies on callbacks to manage middleware execution, while Koa leverages modern JavaScript features like await/async for cleaner asynchronous code flow.

Middleware Execution Model

Express and Koa implement different middleware execution patterns. Express does not strictly follow the onion model—when using async/await, middleware executes in a less predictable order. Koa, however, strictly adheres to the onion model, where each middleware executes both before and after the next middleware in the chain, ensuring predictable behavior.

Error Handling

Express uses callbacks to capture exceptions, which can fail to catch errors in deeply nested asynchronous operations. Koa employs try/catch blocks within its middleware pipeline, providing more reliable error detection and handling throughout the application.

Express Implementation

const express = require('express');
const path = require('path');
const fs = require('fs');

const app = express();

function delay(ms) {
  return new Promise(resolve => {
    setTimeout(resolve, ms);
  });
}

app.use(async function(request, response, proceed) {
  console.log('first middleware begins', Date.now());
  proceed();
  console.log('first middleware finishes', Date.now());
});

app.use(async function(request, response, proceed) {
  console.log('second middleware begins', Date.now());
  proceed();
  console.log('second middleware finishes', Date.now());
});

app.get('/home', (request, response) => {
  response.send('Welcome to Express');
});

app.listen(7777, () => {
  console.log('Express server running on port 7777');
});

Output with async/await:

first middleware begins 1639029830146
second middleware begins 1639029831154
first middleware finishes 1639029831154
second middleware finishes 1639029833165

Output without async/await:

first middleware begins 1639029881890
second middleware begins 1639029881891
second middleware finishes 1639029881898
first middleware finishes 1639029881898

Koa Implementation

const Koa = require('koa');
const Router = require('koa-router');

const app = new Koa();
const router = new Router();

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

app
  .use(router.routes())
  .use(router.allowedMethods());

router.use(async function(context, next) {
  console.log('first middleware begins', Date.now());
  next();
  console.log('first middleware finishes', Date.now());
});

router.use(async function(context, next) {
  console.log('second middleware begins', Date.now());
  next();
  console.log('second middleware finishes', Date.now());
});

router.get('/home', (context) => {
  context.body = 'Welcome to Koa';
});

app.listen(8888, () => {
  console.log('Koa server running on port 8888');
});

Output with async/await:

first middleware begins 1639029988309
second middleware begins 1639029989311
second middleware finishes 1639029991316
first middleware finishes 1639029991316

Output without async/await:

first middleware begins 1639030056718
second middleware begins 1639030056718
second middleware finishes 1639030056719
first middleware finishes 1639030056719

Internal Architecture Differences

Koa's middleware composition uses a dispatch mechanism that recursively processes middleware in sequence. The compose function creates a chain where each middleware receives a reference to the next middleware through the dispatch function, enabling the proper onion-layer execution pattern.

Expres, conversely, processes middleware in a more linear fashion. The framework iterates through the middleware stack and executes each function, but the execution flow differs when async operations are involved, leading to the observed timing differences in the output logs.