What is Express

A minimal, unopinionated web framework for Node.js - what Express adds on top of the raw http module, and why almost every Node.js backend starts here.

What it is, in plain English: Express is a web application framework for Node.js. It sits on top of Node's built-in http module and adds the things every server needs but http alone doesn't provide easily: clean routing (matching URLs and HTTP methods to handler functions), middleware (a pipeline for processing requests), and convenient request/response helpers. Express is deliberately minimal -- it doesn't force a project structure or include a database layer, which is why it has remained the most widely used Node.js framework for over a decade.

The framework almost every Node.js backend starts with

Node.js gives you the http module to build servers, but using it directly means manually parsing URLs, checking HTTP methods with if/else chains, and writing headers by hand for every response. Express wraps all of that in a clean, declarative API.

Installing and the simplest server

# npm init -y
# npm install express

import express from "express";

const app = express();

app.get("/", (req, res) => {
  res.send("Hello, World!");
});

app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

Compare this to raw Node.js http

// Raw http module -- you handle EVERYTHING manually:
import { createServer } from "http";

createServer((req, res) => {
  if (req.method === "GET" && req.url === "/") {
    res.writeHead(200, { "Content-Type": "text/plain" });
    res.end("Hello, World!");
  }
  // ...and an if/else branch for every single route
}).listen(3000);

// Express -- the SAME thing, but declarative and readable:
app.get("/", (req, res) => res.send("Hello, World!"));
// Express handles: parsing the URL, matching the method, setting
// Content-Type automatically based on what you send, and 404 for
// anything that doesn't match any route.

What Express gives you out of the box

// 1. Clean routing -- app.get, app.post, app.put, app.delete:
app.get("/users", handler);
app.post("/users", handler);

// 2. Route parameters -- no manual URL parsing:
app.get("/users/:id", (req, res) => {
  res.send(`User ID: ${req.params.id}`);
});

// 3. Easy response helpers:
res.send("text or html");
res.json({ key: "value" });
res.status(404).send("Not found");
res.redirect("/login");

// 4. Middleware -- a pipeline for processing every request (covered next page)
app.use(express.json());   // parse JSON request bodies automatically

What Express deliberately does NOT include

// Express is "unopinionated" -- it doesn't force a project structure
// or bundle a database, unlike fuller frameworks (Rails, Django, NestJS).
// You choose your own:
// - Database:        PostgreSQL + Prisma, MongoDB + Mongoose, anything
// - Project structure: MVC, flat, feature-folders -- your choice
// - Validation:       Zod, Joi, express-validator -- your choice
// - Authentication:   Passport.js, custom JWT, anything

// This is WHY Express has remained dominant for over a decade --
// it's a thin, flexible layer, not a rigid framework you must conform to.

Try It Yourself (Node.js logic)

// What Express adds on top of raw Node.js http
// (Express needs a real Node.js + npm environment to run --
//  this Try It shows the CODE STRUCTURE and logic, run it with 'node server.js' for a live server)

// WITHOUT Express -- raw http module (verbose, manual routing):
const RAW_HTTP_CODE = `
import { createServer } from "http";

server.listen(3000);
`;

// WITH Express -- same behaviour, dramatically less code:
const EXPRESS_CODE = `
import express from "express";
const app = express();

app.get("/", (req, res) => {
  res.send("Home page");
});

app.get("/about", (req, res) => {
  res.send("About page");
});

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

app.listen(3000);
`;

console.log("WITHOUT Express (raw http module):");
console.log(RAW_HTTP_CODE.trim());
console.log("\nWITH Express:");
console.log(EXPRESS_CODE.trim());
console.log("\nExpress eliminates manual URL parsing, method checking, and header management.");

// Demonstrating the conceptual model (route matching logic) without a real server:
const routes = [
  { method: "GET", path: "/",         handler: () => "Home page" },
  { method: "GET", path: "/about",    handler: () => "About page" },
];

function matchRoute(method, path) {
  const route = routes.find(r => r.method === method && r.path === path);
  return route ? route.handler() : "404 Not Found";
}

console.log("\nSimplified routing logic Express handles for you:");
console.log(matchRoute("GET", "/"));
console.log(matchRoute("GET", "/about"));
console.log(matchRoute("GET", "/missing"));

The Express ecosystem and when to consider alternatives

Express's position in the Node.js framework landscape

// Express      -- the original, huge ecosystem, battle-tested, slightly dated API
// Fastify       -- faster, schema-based validation built in, modern async/await-first API
// Koa            -- by the Express team, async middleware via generators, more minimal
// Hono           -- ultra-fast, runs on Cloudflare Workers/Bun/Deno/Node, TypeScript-first
// NestJS         -- Angular-inspired, decorators, dependency injection, opinionated structure

// Express remains the default choice because of its ecosystem size --
// almost every Node.js library has an Express-compatible middleware
// or first-class Express documentation, even years after release.

A realistic small app structure

// app.js
import express from "express";
import usersRouter from "./routes/users.js";
import { errorHandler } from "./middleware/errorHandler.js";

const app = express();

app.use(express.json());           // parse JSON bodies
app.use("/api/users", usersRouter); // mount a router for /api/users/*
app.use(errorHandler);              // catch-all error handler, LAST

export default app;

// server.js (the actual entry point)
import app from "./app.js";
app.listen(3000, () => console.log("Listening on 3000"));

// Splitting app.js from server.js makes the app testable --
// tests can import 'app' and use supertest without actually starting a server.

Express 5 vs Express 4

// Express 5 (current major version) changes:
// - Promise rejections in async route handlers are now caught automatically
//   (Express 4 required manual try/catch or a wrapper library)
// - Removed several deprecated methods (res.send(status) no longer works as shorthand)
// - Path matching uses path-to-regexp v6+ (slightly different wildcard syntax)

// Express 4 is still extremely common in existing codebases and tutorials --
// always check which version a guide assumes.

How Express is built on top of http, internally

// Express's app object IS a request handler function compatible with
// Node's raw http.createServer -- this is why app.listen() works:
import http from "http";
import express from "express";

const app = express();
// app.listen(3000) is roughly equivalent to:
// http.createServer(app).listen(3000);
// 'app' itself is a function: (req, res) => { ...routing logic... }

// The middleware/routing system is built around a linked chain of functions,
// each calling next() to pass control to the next one -- this IS the core
// Express architecture, not an abstraction on top of something else:
function simplifiedExpressLogic(req, res, middlewareStack) {
  let index = 0;
  function next(err) {
    if (err) return handleError(err);
    const layer = middlewareStack[index++];
    if (!layer) return send404(res);
    layer(req, res, next);   // each middleware calls next() to continue
  }
  next();
}

Why Express stayed minimal by design

Express's original design philosophy (inherited from Sinatra in the Ruby world) was a deliberate reaction against heavier, more prescriptive frameworks. By staying close to raw HTTP semantics — request in, response out, middleware as plain functions — Express imposed almost no learning curve beyond Node.js itself, and any Express version could interoperate with code written for vastly different Express versions or styles, since middleware is just a function signature contract: (req, res, next) => {}.

Official Sources

The Codex links only to official documentation. No third-party tutorials.