Fastify

Backend Frameworks

Fast and low overhead web framework for Node.js

weekly downloads4.9M

versionv5.7.4

licenseMIT

2x faster than ExpressSchema-based validationPlugin system

Overview

Fastify is a high-performance web framework for Node.js that prioritizes speed, developer experience, and extensibility. Built from the ground up with modern JavaScript features, it delivers approximately 30,000-76,000+ requests per second—roughly five times faster than Express—while maintaining robust schema validation and security features.

The framework distinguishes itself through JSON Schema-based request validation and response serialization. This approach compiles schemas into highly optimized functions that validate incoming data and serialize responses 2-3x faster than standard JSON.stringify(), while preventing accidental data leakage. Unlike Express, Fastify provides native async/await support throughout its API, eliminating the need for callback patterns or manual error handling wrappers.

Fastify's plugin architecture enables true encapsulation and dependency management, allowing developers to build modular applications where plugins can have their own isolated scope, decorators, and hooks. The framework includes comprehensive TypeScript support with built-in type definitions, making it suitable for large-scale applications requiring type safety. With nearly 5 million weekly downloads, Fastify has become the go-to choice for teams building high-traffic APIs, microservices, and real-time applications where performance and resource efficiency are critical.

The framework was inspired by Hapi and Express but redesigned to leverage modern V8 optimizations and Node.js capabilities. Its ecosystem includes plugins for common tasks like authentication, CORS, rate limiting, and database integration, all following the same encapsulation principles that make Fastify applications maintainable and testable.

Quick Start

typescript

const fastify = require('fastify')({
  logger: true
});

const userSchema = {
  body: {
    type: 'object',
    required: ['email', 'name'],
    properties: {
      email: { type: 'string', format: 'email' },
      name: { type: 'string', minLength: 2 },
      age: { type: 'integer', minimum: 0 }
    }
  },
  response: {
    201: {
      type: 'object',
      properties: {
        id: { type: 'string' },
        email: { type: 'string' },
        name: { type: 'string' },
        createdAt: { type: 'string' }
      }
    }
  }
};

fastify.post('/users', { schema: userSchema }, async (request, reply) => {
  const { email, name, age } = request.body;
  
  const user = {
    id: crypto.randomUUID(),
    email,
    name,
    age,
    createdAt: new Date().toISOString(),
    internalToken: 'secret-not-serialized'
  };
  
  reply.code(201).send(user);
});

fastify.get('/users/:id', async (request, reply) => {
  const { id } = request.params;
  
  return {
    id,
    email: 'user@example.com',
    name: 'John Doe'
  };
});

const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

Use Cases

High-traffic REST APIs: Fastify excels at serving APIs handling tens of thousands of requests per second, making it ideal for SaaS platforms, e-commerce backends, or any service where response time and throughput directly impact business metrics. The schema-based validation ensures data integrity without performance penalties.

Microservices architecture: The plugin system's encapsulation and dependency injection make Fastify perfect for building microservices where each service needs modular, testable components. The low memory footprint allows running more service instances per server, reducing infrastructure costs.

Real-time data streaming: With native async/await support and efficient routing, Fastify handles server-sent events (SSE) and WebSocket connections effectively, suitable for chat applications, live dashboards, or IoT data pipelines requiring low latency.

GraphQL servers: Fastify's performance characteristics and plugin ecosystem (like mercurius) make it an excellent choice for GraphQL APIs where resolver execution speed and schema validation are critical for complex queries.

Proxy and gateway services: The framework's minimal overhead and efficient request lifecycle make it ideal for building API gateways, reverse proxies, or edge services that need to handle and transform requests quickly without introducing significant latency.

Pros & Cons

Pros

+Exceptional performance with 5x+ throughput compared to Express, significantly reducing infrastructure costs for high-traffic applications
+Schema-based validation and serialization provides automatic type checking, API documentation generation, and protection against data leakage
+True plugin encapsulation with dependency injection enables modular architecture and prevents scope pollution common in Express middleware
+First-class TypeScript support and native async/await throughout the API eliminates common pitfalls and improves code maintainability
+Comprehensive lifecycle hooks (onRequest, preValidation, preHandler, onSend, onResponse, onError) provide fine-grained control over request processing

Cons

−Smaller ecosystem compared to Express means fewer third-party plugins and less Stack Overflow coverage for niche issues
−JSON Schema syntax can be verbose and less intuitive than TypeScript or Joi schemas, requiring a learning curve for complex validations
−Breaking changes between major versions (v3 to v4 to v5) can require migration effort for existing applications
−Plugin encapsulation, while powerful, adds complexity and can confuse developers migrating from simpler middleware patterns
−Some Express middleware requires adapter plugins to work with Fastify, and not all Express middleware is compatible

Comparisons

express vs fastifybackend →fastify vs honobackend →nestjs vs fastifybackend →

Install

bash

npm install fastify

bash

pnpm add fastify

bash

bun add fastify

↗ View full npm package details