Making HTTP Servers

Three ways to build HTTP servers in Node.js — node:http for zero dependencies, Express for familiarity, Fastify for performance.

Recipe

Quick-reference recipe card — copy-paste ready.

// 1. node:http — zero dependencies
import { createServer } from "node:http";
 
createServer((req, res) => {
  res.writeHead(200, { "content-type": "application/json" });
  res.end(JSON.stringify({ ok: true }));
}).listen(3000);
 
// 2. Express — the familiar choice
import express from "express";
 
const app = express();
app.use(express.json());
app.get("/", (req, res) => res.json({ ok: true }));
app.listen(3000);
 
// 3. Fastify — high performance
import Fastify from "fastify";
 
const fastify = Fastify({ logger: true });
fastify.get("/", async () => ({ ok: true }));
await fastify.listen({ port: 3000 });

When to reach for this: Any time you need a long-running HTTP service — internal APIs, webhooks, SSR fallbacks, background workers with a health endpoint.

Working Example

A tiny REST API with three routes — GET /, GET /users/:id, POST /users — side by side in all three frameworks.

// --- node:http ---
import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
 
type User = { id: string; name: string };
const users = new Map<string, User>();
 
const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
  res.setHeader("content-type", "application/json");
 
  if (req.method === "GET" && req.url === "/") {
    res.end(JSON.stringify({ ok: true }));
    return;
  }
 
  const idMatch = req.url?.match(/^\/users\/([^/]+)$/);
  if (req.method === "GET" && idMatch) {
    const user = users.get(idMatch[1]);
    if (!user) {
      res.statusCode = 404;
      res.end(JSON.stringify({ error: "not found" }));
      return;
    }
    res.end(JSON.stringify(user));
    return;
  }
 
  if (req.method === "POST" && req.url === "/users") {
    let body = "";
    for await (const chunk of req) body += chunk;
    const parsed = JSON.parse(body) as User;
    users.set(parsed.id, parsed);
    res.statusCode = 201;
    res.end(JSON.stringify(parsed));
    return;
  }
 
  res.statusCode = 404;
  res.end(JSON.stringify({ error: "not found" }));
});
 
server.listen(3000, () => console.log("node:http on :3000"));

// --- Express ---
import express, { type Request, type Response } from "express";
 
type User = { id: string; name: string };
const users = new Map<string, User>();
 
const app = express();
app.use(express.json());
 
app.get("/", (_req: Request, res: Response) => {
  res.json({ ok: true });
});
 
app.get("/users/:id", (req: Request<{ id: string }>, res: Response) => {
  const user = users.get(req.params.id);
  if (!user) return res.status(404).json({ error: "not found" });
  res.json(user);
});
 
app.post("/users", (req: Request<unknown, unknown, User>, res: Response) => {
  users.set(req.body.id, req.body);
  res.status(201).json(req.body);
});
 
app.listen(3000, () => console.log("express on :3000"));

// --- Fastify ---
import Fastify from "fastify";
 
type User = { id: string; name: string };
const users = new Map<string, User>();
 
const fastify = Fastify({ logger: true });
 
fastify.get("/", async () => ({ ok: true }));
 
fastify.get<{ Params: { id: string } }>("/users/:id", async (req, reply) => {
  const user = users.get(req.params.id);
  if (!user) return reply.code(404).send({ error: "not found" });
  return user;
});
 
fastify.post<{ Body: User }>(
  "/users",
  {
    schema: {
      body: {
        type: "object",
        required: ["id", "name"],
        properties: {
          id: { type: "string" },
          name: { type: "string" },
        },
      },
    },
  },
  async (req, reply) => {
    users.set(req.body.id, req.body);
    return reply.code(201).send(req.body);
  }
);
 
await fastify.listen({ port: 3000 });

What this demonstrates:

• node:http forces you to handle routing, body parsing, and status codes yourself — minimal but verbose.
• Express middleware (express.json()) gives you req.body for free and uses familiar req/res semantics.
• Fastify adds schema-based validation and serialization, plus a built-in logger, with async handlers by default.

Deep Dive

How It Works

All three frameworks ultimately wrap node:http. createServer returns an http.Server — itself an EventEmitter — that emits 'request' for each incoming message. Express and Fastify install a single 'request' listener that runs their routing and middleware pipelines.

Express uses a linear middleware chain: each function calls next() to pass control. Fastify uses a schema-driven hook system with precompiled JSON serializers, which is where most of its speed comes from.

Variations

node:http with JSON parsing. There is no built-in body parser — read the request as an async iterable of buffers and parse manually (see the working example). For large bodies, guard against unbounded memory with a byte limit.

Express middleware chain. Order matters. Put express.json() before routes that need req.body, put error handlers (functions with four parameters) last, and mount CORS/helmet before any business logic.

Fastify schemas. Declaring a JSON schema for body, params, querystring, and response validates input automatically and compiles a fast serializer for the response. You get 400 errors for free on bad input.

Async route handlers. Express 4 silently swallows thrown errors in async handlers unless you wrap them or use express-async-errors. Express 5 forwards rejected promises to the error middleware. Fastify awaits async handlers natively.

Graceful shutdown. Listen for SIGTERM, stop accepting new connections with server.close(), and drain in-flight requests before exiting:

process.on("SIGTERM", () => {
  server.close(() => process.exit(0));
  setTimeout(() => process.exit(1), 10_000).unref();
});

Health check endpoint. Add GET /healthz returning 200 for liveness. Keep it dependency-free so a broken DB does not fail the liveness probe — use /readyz for dependency checks.

CORS and error middleware. For Express, app.use(cors()) early, and a final (err, req, res, next) => ... error handler last. For Fastify, register @fastify/cors and use setErrorHandler.

TypeScript Notes

For node:http, import IncomingMessage and ServerResponse from node:http and annotate the handler signature. For Express, install @types/express and use Request and Response — Request takes generics for params, response body, request body, and query: Request<Params, ResBody, ReqBody, Query>. For Fastify, pass a generics object directly to the route: fastify.get<\{ Params: \{ id: string \} \}>("/users/:id", handler) (escape braces when writing this in markdown). Fastify's generics also support Body, Querystring, Headers, and Reply.

Gotchas

1. Forgetting res.end() in node:http. The request hangs until the client times out. Every code path must call res.end() (or res.writeHead().end()), including error branches.
2. Unhandled errors in async Express 4 handlers. A thrown error or rejected promise is silently swallowed and the request hangs. Wrap handlers or upgrade to Express 5.
3. Middleware order. express.json() after a route means req.body is undefined. CORS after routes means preflight requests 404. Error handlers before routes never fire.
4. CORS preflight. Browsers send OPTIONS before non-simple requests. If your router only registers GET/POST, preflight fails. Use a CORS middleware that handles OPTIONS globally.
5. EADDRINUSE on restart. The previous process still holds the port. Either kill it, wait for the TIME_WAIT window, or set server.listen(\{ port, exclusive: false \}) — escaped braces in prose.
6. Manual JSON parsing in node:http. Reading the whole body into a string lets a malicious client OOM your process. Enforce a max size and reject oversized requests with 413.
7. Mixing return and res.send in Express. Returning a value does nothing; Express only responds when you call res.send/res.json. In Fastify, the opposite — returning the value sends it.

Alternatives

FAQs

Related

• docs/nodejs-scripts/event-emitter.md — http.Server is an EventEmitter, so the same patterns apply.
• docs/nextjs-routing/app-router.md — Next.js App Router handlers as an alternative for app-coupled endpoints.
• docs/nextjs-data/fetching.md — calling HTTP APIs from the client and server sides of a Next.js app.