NestJS vs Express vs Fastify comparison - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a basic NestJS controller method that handles GET requests.

NestJS

import { Controller, [1] } from '@nestjs/common';

@Controller('hello')
export class HelloController {
  @[1]()
  getHello() {
    return 'Hello World!';
  }
}

Drag options to blanks, or click blank then click option'

AGet

BPost

CPut

DDelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Post instead of @Get for GET requests.

Forgetting to import the decorator from '@nestjs/common'.

The @Get() decorator marks the method to handle HTTP GET requests in NestJS controllers.

2fill in blank

medium

Complete the code to create an Express route handler that responds with 'Hello Express!'.

NestJS

import express from 'express';
const app = express();

app.[1]('/', (req, res) => {
  res.send('Hello Express!');
});

Drag options to blanks, or click blank then click option'

Aget

Bput

Cpost

Ddelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using app.post instead of app.get for GET requests.

Forgetting to call res.send() to send a response.

The app.get() method defines a route handler for HTTP GET requests in Express.

3fill in blank

hard

Fix the error in the Fastify route registration to correctly handle GET requests.

NestJS

import Fastify from 'fastify';
const fastify = Fastify();

fastify.[1]('/', async (request, reply) => {
  return 'Hello Fastify!';
});

Drag options to blanks, or click blank then click option'

Aregister

Bget

Clisten

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using fastify.post instead of fastify.get for GET requests.

Using fastify.listen or fastify.register incorrectly as route handlers.

Fastify uses fastify.get() to register handlers for GET requests.

4fill in blank

hard

Fill both blanks to create a NestJS controller method that uses Express's response object to send JSON.

NestJS

import { Controller, Injectable, [1] } from '@nestjs/common';
import { Response } from 'express';

@Controller()
@Injectable()
export class AppController {
  @[1]()
  sendJson(res: [2]) {
    res.json({ message: 'Hello from NestJS with Express!' });
  }
}

Drag options to blanks, or click blank then click option'

ARes

BRequest

CResponse

DReq

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Request or @Req instead of @Res for response injection.

Using wrong type like Request instead of Response.

In NestJS, the @Res() decorator injects the Express response object, which is of type Response.

5fill in blank

hard

Fill all three blanks to create a Fastify route with schema validation and a handler that returns a greeting.

NestJS

fastify.route({
  method: '[1]',
  url: '/greet',
  schema: {
    querystring: {
      type: 'object',
      properties: {
        name: { type: 'string' }
      },
      required: ['[2]']
    }
  },
  handler: async (request, reply) => {
    const name = request.query.[3];
    return { greeting: `Hello, ${name}!` };
  }
});

Drag options to blanks, or click blank then click option'

Aget

Bname

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using POST method instead of GET for this route.

Mismatching required query parameter name and property accessed.

The route uses HTTP GET method, requires 'name' in query string, and accesses it via request.query.name.

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