Fastify

Fastify is a Node.js web framework focused on performance and developer experience, built from the ground up around JSON Schema-based request/response validation and serialization. Route handlers declare their expected input and output shapes as schemas, which Fastify compiles ahead of time into highly optimized validation and serialization functions, giving it consistently strong throughput in framework benchmarks.

Its architecture is fully plugin-based (built on avvio), with an encapsulation model that scopes decorators, hooks, and plugins to the part of the route tree where they’re registered — preventing global state leakage across a large application. A large first-party and community plugin ecosystem covers authentication, CORS, rate limiting, Swagger/OpenAPI generation, and more, making it a common choice for teams that want an Express-like developer experience with materially better raw performance and built-in schema validation.

What You Get

• JSON Schema-based request validation and response serialization compiled for high performance
• An encapsulated plugin architecture (built on avvio) that scopes decorators and hooks per route subtree
• A rich hooks lifecycle (onRequest, preHandler, onSend, etc.) for cross-cutting request logic
• Built-in structured logging via Pino with per-request log correlation
• First-party plugins for CORS, rate limiting, JWT auth, multipart uploads, and Swagger/OpenAPI docs
• Full TypeScript type definitions and first-class async/await handler support

Common Use Cases

• Building high-throughput REST or JSON APIs where request/response validation overhead matters
• Structuring large applications with route-scoped plugins to avoid global middleware side effects
• Auto-generating OpenAPI/Swagger documentation directly from route JSON schemas
• Migrating from Express when raw throughput or built-in schema validation become priorities

Under The Hood

Architecture - Fastify’s core (fastify.js, lib/) builds the server around avvio for ordered, encapsulated plugin/dependency booting, find-my-way for radix-tree routing, and a lifecycle hooks system (lib/hooks.js) that runs onRequest/preHandler/onSend etc. around each request; each plugin registration creates a new encapsulation context so decorators and hooks don’t leak outside their subtree. Tech Stack - Written in modern CommonJS JavaScript with companion TypeScript type definitions (fastify.d.ts, types/), using Pino for logging, fast-json-stringify/ajv under the hood for schema compilation, and published as a single fastify package with a large satellite plugin ecosystem (@fastify/*). Code Quality - The project enforces 100% line coverage in CI (coverage:ci-check-coverage runs borp --check-coverage --lines 100), combined with ESLint, a dedicated test:types pass via tstyche, and a large test/ directory covering routing, validation, hooks, and plugin encapsulation edge cases. API Design - Route definitions pair a plain object handler with JSON Schema for validation/serialization (fastify.get('/route', { schema }, handler)), which front-loads some schema-authoring effort compared to schema-less frameworks like Express but pays off in both runtime performance and self-documenting APIs.