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.

Practice

1. Which framework is known for providing a structured architecture with decorators and dependency injection?

easy

A. Fastify

B. Express

C. NestJS

D. Koa

Solution

1. Step 1: Understand framework features

   NestJS is designed with a modular architecture, using decorators and dependency injection to organize code clearly.

2. Step 2: Compare with other frameworks

   Express is minimal and flexible but lacks built-in structure; Fastify focuses on speed but not on architectural patterns.

3. Final Answer:

   NestJS -> Option C

4. Quick Check:

   Structured framework = NestJS [OK]

Hint: Structured + decorators = NestJS [OK]

Common Mistakes:

• Confusing Express's flexibility with structure
• Thinking Fastify has built-in dependency injection
• Choosing Koa which is unrelated here

2. Which of the following is the correct way to create a Fastify server instance?

easy

A. const app = fastify();

B. const app = express();

C. const app = new NestFactory();

D. const app = new Koa();

Solution

1. Step 1: Recall Fastify server creation syntax

   Fastify servers are created by calling the fastify() function, not using new keyword.

2. Step 2: Eliminate other options

   Express uses express(), NestJS uses NestFactory.create(), and Koa uses new Koa().

3. Final Answer:

   const app = fastify(); -> Option A

4. Quick Check:

   Fastify instance = fastify() [OK]

Hint: Fastify uses fastify() function call [OK]

Common Mistakes:

• Using new keyword with fastify
• Confusing Express and Fastify syntax
• Using NestFactory directly for Fastify

3. Given the following code snippet, what will be the main difference in performance between NestJS using Express and Fastify?

const app = await NestFactory.create(AppModule, { logger: true });
await app.listen(3000);

medium

A. NestJS with Express is faster due to simpler middleware

B. NestJS with Fastify is faster due to optimized HTTP handling

C. Both have identical performance because NestJS abstracts the server

D. NestJS with Express supports HTTP/2 by default, Fastify does not

Solution

1. Step 1: Understand NestJS adapters

   NestJS can use Express or Fastify under the hood. Fastify is designed for speed and efficiency.

2. Step 2: Compare performance traits

   Fastify has optimized HTTP handling and lower overhead, making it faster than Express in most cases.

3. Final Answer:

   NestJS with Fastify is faster due to optimized HTTP handling -> Option B

4. Quick Check:

   Fastify = faster HTTP handling [OK]

Hint: Fastify is faster than Express in NestJS [OK]

Common Mistakes:

• Assuming Express is faster due to simplicity
• Thinking NestJS removes all performance differences
• Confusing HTTP/2 support defaults

4. You wrote a NestJS app using Fastify adapter but get an error: TypeError: app.listen is not a function. What is the most likely cause?

medium

A. You forgot to import FastifyModule in AppModule

B. Fastify does not support listen method

C. You called app.listen before await

D. You did not use NestFactory.create with Fastify adapter

Solution

1. Step 1: Check how NestJS app is created with Fastify

   To use Fastify, you must pass the Fastify adapter to NestFactory.create().

2. Step 2: Understand error cause

   If you skip the adapter, NestJS defaults to Express, but if you mix Fastify code without adapter, app.listen may be undefined.

3. Final Answer:

   You did not use NestFactory.create with Fastify adapter -> Option D

4. Quick Check:

   Fastify adapter required for app.listen [OK]

Hint: Use Fastify adapter in NestFactory.create [OK]

Common Mistakes:

• Assuming FastifyModule import is enough
• Calling listen without await causes different error
• Thinking Fastify lacks listen method

5. You want to build a high-performance REST API with automatic validation, modular structure, and fast response times. Which combination best fits this requirement?

hard

A. NestJS using Fastify adapter with class-validator and modules

B. Fastify with no framework on top

C. NestJS using Express adapter without validation

D. Express with manual middleware and no structure

Solution

1. Step 1: Identify requirements

   High performance, automatic validation, and modular structure require a framework with features and speed.

2. Step 2: Match frameworks to needs

   Express alone lacks structure and automatic validation; Fastify alone lacks modularity; NestJS provides structure and validation, and Fastify adapter adds speed.

3. Final Answer:

   NestJS using Fastify adapter with class-validator and modules -> Option A

4. Quick Check:

   Structure + validation + speed = NestJS + Fastify [OK]

Hint: Combine NestJS structure + Fastify speed + validation [OK]

Common Mistakes:

• Choosing Express for automatic validation
• Ignoring modularity in Fastify alone
• Using NestJS with Express loses speed advantage