NestJS vs Express vs Fastify comparison - Visual Side-by-Side Comparison

Concept Flow - NestJS vs Express vs Fastify comparison

Start Request

↓

NestJS Middleware

↓

NestJS Controller

↓

Underlying HTTP Framework

↓

Express

↓

Handle Request & Response

↓

Send Response

↓

End

Shows how NestJS handles requests by using middleware and controllers, then delegates to an underlying HTTP framework like Express or Fastify to process and respond.

Execution Sample

NestJS

import { Controller, Get } from '@nestjs/common';
@Controller('hello')
export class HelloController {
  @Get()
  getHello() { return 'Hello World'; }
}

A simple NestJS controller that responds with 'Hello World' when a GET request is made to /hello.

Execution Table

Step	Action	NestJS Layer	Underlying Framework	Result
1	Receive HTTP GET /hello	Middleware processes request	Express or Fastify receives request	Request passed to controller
2	Controller method getHello() called	Controller handles route	Underlying framework idle	Returns 'Hello World' string
3	NestJS sends response	Response prepared	Underlying framework sends HTTP response	Client receives 'Hello World'
4	Request cycle ends	Cleanup if needed	Request closed	Ready for next request

💡 Request handled fully by NestJS and underlying framework sends response back to client

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
request	undefined	HTTP GET /hello object	Passed to controller	Response prepared	Request closed
response	undefined	undefined	undefined	'Hello World' string	Sent to client

Key Moments - 2 Insights

Why does NestJS use Express or Fastify under the hood?

NestJS is a framework that builds on top of existing HTTP servers like Express or Fastify to add structure and features. The execution_table shows NestJS middleware and controllers handle logic, but the underlying framework manages the actual HTTP request and response.

How does Fastify differ from Express in this setup?

Fastify is designed for speed and low overhead, so when NestJS uses Fastify (seen in the underlying framework column), requests may be processed faster compared to Express. The flow is similar but performance differs.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at Step 2?

A NestJS controller method is called to handle the route

B Underlying framework sends the HTTP response

C Request is received by the server

D Request cycle ends and cleanup happens

💡 Hint

Check the 'Action' and 'NestJS Layer' columns at Step 2 in the execution_table

At which step does the client receive the 'Hello World' response?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for when the response is sent to the client in the 'Result' column

If NestJS used only Express, which column in the execution_table would change?

A NestJS Layer

B Underlying Framework

C Action

D Result

💡 Hint

The 'Underlying Framework' column shows which HTTP server is used

Concept Snapshot

NestJS is a framework that uses Express or Fastify underneath.
It adds structure with controllers and middleware.
Express is popular and easy; Fastify is faster and lighter.
NestJS handles routing and logic; Express/Fastify handle HTTP.
Choose Fastify for speed, Express for ecosystem.
NestJS lets you switch easily between them.

Full Transcript

This visual execution compares NestJS with Express and Fastify. NestJS acts as a structured layer on top of HTTP servers like Express or Fastify. When a request comes in, NestJS middleware processes it, then the controller handles the route logic. The underlying framework (Express or Fastify) manages the actual HTTP request and response. Express is widely used and easy to work with, while Fastify offers better performance. The execution table shows the step-by-step flow: receiving the request, calling the controller, preparing the response, and sending it back to the client. Variables like request and response change state through these steps. Key points include understanding NestJS's role as a wrapper and the performance differences between Express and Fastify. The quiz tests understanding of these steps and roles. Overall, NestJS provides a clean structure while leveraging powerful HTTP frameworks underneath.

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