NestJS vs Express vs Fastify comparison - Trade-offs & Expert Analysis

Overview - NestJS vs Express vs Fastify comparison

What is it?

NestJS, Express, and Fastify are popular frameworks used to build web servers in JavaScript and TypeScript. Express is a minimal and flexible framework that provides basic tools to create web applications. Fastify is a newer framework focused on speed and low overhead. NestJS is a higher-level framework built on top of Express or Fastify, offering a structured way to build scalable server applications using modern programming patterns.

Why it matters

Choosing the right framework affects how fast you can build, how well your app performs, and how easy it is to maintain. Without these frameworks, developers would have to write a lot of repetitive code for handling requests, responses, and routing, making development slower and more error-prone. Understanding their differences helps you pick the best tool for your project’s needs.

Where it fits

Before learning this, you should know basic JavaScript or TypeScript and understand what a web server does. After this, you can explore advanced backend topics like microservices, serverless functions, or performance optimization.

Mental Model

Core Idea

Express is the simple foundation, Fastify is the fast and efficient engine, and NestJS is the organized architect that builds on them to create scalable applications.

Think of it like...

Imagine building a house: Express is like having basic tools and materials, Fastify is like having power tools that speed up construction, and NestJS is like having an architect and project manager who organizes everything for a bigger, complex house.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│   Express   │──────▶│   Fastify   │       │   NestJS    │
│ (Basic tools│       │ (Power tools│       │ (Architect) │
│  & materials)│       │  for speed) │       │  & manager) │
└─────────────┘       └─────────────┘       └─────────────┘
       ▲                    ▲                    ▲
       │                    │                    │
       └────────────────────┴────────────────────┘
                 Web Server Frameworks

Build-Up - 7 Steps

1

Foundation

Understanding Express Basics

Concept: Learn what Express provides as a minimal web framework.

Express offers simple routing, middleware support, and request/response handling. It lets you create endpoints like GET or POST easily. For example, you can write a server that responds to a URL with a message using just a few lines of code.

Result

You can build a basic web server that listens to requests and sends responses.

Knowing Express’s simplicity helps you appreciate why it’s widely used and how it forms the base for other frameworks.

2

Foundation

Introducing Fastify for Speed

Concept: Fastify is designed to be faster and more efficient than Express.

Fastify uses a schema-based approach to validate and serialize data, which reduces processing time. It also optimizes how it handles requests internally to improve throughput. The API is similar to Express but with added focus on performance.

Result

You get a web server that can handle more requests per second with less delay.

Understanding Fastify’s focus on speed shows how design choices impact real-world app performance.

3

Intermediate

NestJS Structure and Patterns

🤔Before reading on: do you think NestJS is a completely new framework or built on top of existing ones? Commit to your answer.

Concept: NestJS builds on Express or Fastify and adds a structured architecture using modules, controllers, and services.

NestJS uses decorators and dependency injection to organize code into reusable parts. It encourages separation of concerns and testability. You write controllers to handle routes and services for business logic, making large apps easier to manage.

Result

You can build scalable and maintainable server applications with clear organization.

Knowing NestJS’s architecture helps you write cleaner code and manage complexity as projects grow.

4

Intermediate

Middleware and Plugins Comparison

🤔Before reading on: which framework do you think offers the most middleware/plugins out of the box? Express, Fastify, or NestJS? Commit to your answer.

Concept: Each framework supports middleware or plugins differently, affecting extensibility and ecosystem.

Express has a large ecosystem of middleware for tasks like authentication and logging. Fastify uses plugins that are optimized for performance and isolation. NestJS leverages middleware from Express or Fastify but also provides its own decorators and modules for common features.

Result

You understand how to extend functionality and choose the right tools for your needs.

Recognizing middleware differences helps you pick frameworks that fit your project’s extensibility requirements.

5

Intermediate

Performance and Scalability Differences

🤔Before reading on: do you think NestJS is slower than Express or Fastify because of its extra features? Commit to your answer.

Concept: Performance varies due to framework design, but scalability depends on architecture and usage.

Fastify is generally faster than Express because of its optimized internals. NestJS adds some overhead due to its abstraction but can scale well because it encourages modular design. Real-world performance depends on how you write your code and use features.

Result

You can balance speed and maintainability when choosing a framework.

Understanding trade-offs between raw speed and structured design guides better framework selection.

6

Advanced

Choosing Between Express, Fastify, and NestJS

🤔Before reading on: which framework would you pick for a small project versus a large enterprise app? Commit to your answer.

Concept: Framework choice depends on project size, team skills, and priorities like speed or structure.

Use Express for simple or quick prototypes due to its minimalism. Fastify suits projects needing high performance with some structure. NestJS is ideal for large, complex apps requiring maintainability and scalability, especially with TypeScript support.

Result

You can make informed decisions matching framework strengths to project needs.

Knowing when to use each framework prevents overengineering or performance bottlenecks.

7

Expert

Internals and Ecosystem Integration

🤔Before reading on: do you think NestJS can switch between Express and Fastify without code changes? Commit to your answer.

Concept: NestJS abstracts the underlying HTTP platform, allowing flexible integration with Express or Fastify.

NestJS uses an adapter pattern to support multiple HTTP servers. This means you can switch from Express to Fastify by changing configuration without rewriting your app. It also integrates with many libraries for validation, caching, and microservices, making it versatile in production.

Result

You gain flexibility and can optimize your app’s performance or features without major rewrites.

Understanding NestJS’s adapter design reveals how abstraction enables powerful flexibility in real-world apps.

Under the Hood

Express provides a simple middleware stack where each function processes requests in order. Fastify uses a highly optimized routing and serialization system with schema-based validation to reduce overhead. NestJS builds on these by adding a dependency injection container and metadata reflection to manage modules, controllers, and services, enabling a modular and testable architecture.

Why designed this way?

Express was created to be minimal and flexible, allowing developers to add only what they need. Fastify was designed later to address performance bottlenecks in Express by optimizing request handling and serialization. NestJS was built to bring modern software engineering principles like modularity and dependency injection to Node.js backend development, improving maintainability and scalability.

┌───────────────┐
│   Client      │
└──────┬────────┘
       │ HTTP Request
┌──────▼────────┐
│   NestJS      │
│ ┌───────────┐ │
│ │ Controllers│ │
│ │ Services   │ │
│ └────┬──────┘ │
│  Adapter     │
└─────┬────────┘
      │
┌─────▼────────┐
│ Express or   │
│ Fastify Core │
└─────┬────────┘
      │
┌─────▼────────┐
│ Node.js HTTP │
│   Server     │
└──────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Is Express always slower than Fastify? Commit to yes or no.

Common Belief: Express is always slower than Fastify in every situation.

Reality: While Fastify is generally faster, Express can perform similarly in many cases depending on usage and optimizations.

Why it matters: Assuming Express is always slow may lead to unnecessary rewrites or premature optimization.

Quick: Does NestJS force you to use TypeScript? Commit to yes or no.

Common Belief: NestJS only works with TypeScript and cannot be used with plain JavaScript.

Reality: NestJS is built with TypeScript in mind but can be used with JavaScript, though TypeScript unlocks its full benefits.

Why it matters: Believing this limits adoption by developers who prefer JavaScript or are transitioning.

Quick: Does using NestJS mean you cannot access Express or Fastify features directly? Commit to yes or no.

Common Belief: NestJS hides Express or Fastify completely, so you lose access to their features.

Reality: NestJS allows direct access to the underlying platform, so you can use Express or Fastify features when needed.

Why it matters: Misunderstanding this can discourage developers from using NestJS due to fear of losing control.

Quick: Is Fastify’s plugin system incompatible with Express middleware? Commit to yes or no.

Common Belief: Fastify cannot use Express middleware because their systems are incompatible.

Reality: Fastify can use some Express middleware with adapters, but native Fastify plugins are preferred for performance.

Why it matters: This misconception may prevent developers from leveraging existing middleware or cause confusion during migration.

Expert Zone

1

NestJS’s dependency injection system supports hierarchical scopes, allowing fine-grained control over service lifetimes.

2

Fastify’s schema-based serialization not only improves speed but also enhances security by validating data shapes.

3

Express’s middleware order is critical; a single misplaced middleware can break the entire request flow, a subtlety often overlooked.

When NOT to use

Avoid NestJS for very small or simple projects where its structure adds unnecessary complexity; prefer Express for quick prototypes. Avoid Fastify if your project relies heavily on middleware not compatible with it or if your team lacks experience with its plugin system.

Production Patterns

In production, NestJS is often used for large-scale microservices with clear module boundaries. Fastify is chosen for high-throughput APIs needing low latency. Express remains popular for legacy systems and simple REST APIs due to its vast ecosystem.

Connections

Dependency Injection

NestJS builds on the dependency injection pattern to manage components.

Understanding dependency injection clarifies how NestJS organizes and reuses code efficiently.

Event-Driven Architecture

Fastify’s plugin system and NestJS’s event emitters support event-driven designs.

Knowing event-driven concepts helps leverage these frameworks for scalable, decoupled systems.

Project Management

NestJS’s modular structure parallels how project managers organize teams and tasks.

Seeing code organization like project management aids in designing maintainable software.

Common Pitfalls

#1 Using NestJS without understanding its module system leads to tightly coupled code.

Wrong approach:

import { Injectable } from '@nestjs/common';
@Injectable()
export class UserService {
constructor(private readonly otherService: OtherService) {}
}
// All services imported directly without modules

Correct approach:

import { Module } from '@nestjs/common';
@Module({
providers: [UserService, OtherService],
exports: [UserService],
})
export class UserModule {}

Root cause:

Misunderstanding NestJS modules causes poor separation and harder testing.

#2 Assuming Express middleware order does not matter causes bugs.

Wrong approach:

app.use(authMiddleware);
app.use(bodyParser.json()); // bodyParser after auth

Correct approach:

app.use(bodyParser.json());
app.use(authMiddleware); // bodyParser before auth

Root cause:

Middleware must be ordered correctly because each depends on previous processing.

#3 Trying to use all Express middleware in Fastify without adaptation causes errors.

Wrong approach:

fastify.use(expressMiddleware); // Direct use without adapter

Correct approach:

const fastifyExpress = require('fastify-express');
await fastify.register(fastifyExpress);
fastify.use(expressMiddleware);

Root cause:

Fastify and Express have different middleware systems; adapters are needed.

Key Takeaways

Express is a minimal and flexible web framework ideal for simple or quick projects.

Fastify focuses on high performance and efficient request handling using schemas and plugins.

NestJS builds on Express or Fastify to provide a structured, modular architecture for scalable applications.

Choosing between them depends on project size, performance needs, and team familiarity.

Understanding their internals and trade-offs helps you build better backend systems.