How to Migrate Express to Fastify for Faster JSON Serialization

Why Express JSON serialization is the bottleneck

Express uses JSON.stringify for every response. For a route that returns an array of 200 customer objects, JSON.stringify reflects over every property on every object at runtime on every request. At low traffic it's invisible; at a few hundred rps it shows up clearly in profiling as the hot path.

Fastify solves this with fast-json-stringify: given a JSON Schema for the response body, it compiles a dedicated serializer at startup that knows exactly which fields to emit and in what order - no reflection, no per-call key walks.

The Express starting point

import express from "express";
const app = express();

app.get("/api/customers", (req, res) => {
  res.json({ customers: CUSTOMERS, count: CUSTOMERS.length });
});

app.listen(8000);

This works, but every call to res.json() invokes JSON.stringify on the full payload.

The Fastify migration

import Fastify from "fastify";
const fastify = Fastify({ logger: false });

fastify.get(
  "/api/customers",
  {
    schema: {
      response: {
        200: {
          type: "object",
          properties: {
            count: { type: "integer" },
            customers: {
              type: "array",
              items: {
                type: "object",
                properties: {
                  id: { type: "integer" },
                  name: { type: "string" },
                  email: { type: "string" },
                  status: { type: "string" },
                  signup_date: { type: "string" },
                },
              },
            },
          },
        },
      },
    },
  },
  async () => ({ customers: CUSTOMERS, count: CUSTOMERS.length })
);

fastify.listen({ port: 8000, host: "0.0.0.0" });

The handler itself barely changes. The difference is the schema.response[200] block passed as the second argument to fastify.get. Fastify reads that schema at startup, compiles a fast-json-stringify serializer, and uses it for every response - not JSON.stringify.

Why the schema placement matters

The schema goes inside the route options object - the second positional argument between the URL string and the handler function:

fastify.get(url, { schema: { response: { 200: { ... } } } }, handler)
//                 ^^^^^^^^ route options ^^^^^^^^

Omitting the schema is the most common migration mistake. Fastify without a response schema is only marginally faster than Express because it still falls through to JSON.stringify for serialization.

Key differences from Express

• Handler signature - Fastify handlers are async and return the value directly; no res.json() needed.
• Schema is the contract - declare every field you want serialized; undeclared fields are stripped from the response, which also prevents accidental data leaks.
• /health needs no schema - lightweight endpoints with a single small object are fine without one; the overhead there is negligible.