EXPRESS JS VS NEST JS

7 min readJul 3, 2023

When developers embark on building large-scale applications, they often consider frameworks to help them streamline the development process. Among the plethora of options available, Express.js stands out as a go-to choice. Its popularity has soared in recent years due to its simplicity, flexibility, and extensive community support. Developers appreciate Express.js for its minimalist approach, allowing us to build robust web applications with ease. If you’re reading this, you probably already use express.js but if that’s not the case, read all about express.js here.

However, another compelling framework that deserves attention is NestJS.

What is Nest.js?

NestJS is a framework for building server-side applications using Node.js. It is based on TypeScript and JavaScript. It takes inspiration from Angular, another popular framework, so if you know Angular, learning NestJS will be easier for you.

One of the interesting things about NestJS is that it uses the Express HTTP framework by default. However, it is not limited to Express and can work with other Node HTTP frameworks like Fastify, which can make it even better.

Note that NestJS supports all the features available in Express, so anything you can do in Express, you can also do in NestJS.

NestJS has gained a lot of popularity among developers even though it is relatively new. Its foundation in TypeScript and similarities to Angular make it appealing to those familiar with these technologies. It uses decorators, dependency injection, and other architectural patterns to create a structured and scalable application development experience.

This relatively newer player in the framework landscape has gained significant traction among developers. NestJS is built on the foundation of TypeScript and draws inspiration from Angular, making it an attractive option for those familiar with these technologies. It leverages decorators, dependency injection, and other architectural patterns to provide a structured and scalable application development experience.

This article aims to provide valuable insights for developers by examining the significant distinctions between express.js and nest.js across key parameters. By delving into these factors, you will gain a better understanding of the unique features and capabilities of each framework, aiding you in making informed decisions during your development journey.

Get JENNIFER JOSEPH’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

1. Dependency Injection:

Express: Express does not have built-in support for dependency injection. What is Dependency injection? Dependency injection (in very simple terms) is the process of providing the necessary dependencies to a class or function. In Express, developers typically handle dependencies manually or use third-party libraries like InversifyJS or Awilix to achieve dependency injection. This requires additional configuration and setup.
Nest.js: Nest.js, on the other hand, has built-in support for dependency injection. It uses decorators and a module system to manage dependencies. With Nest.js, you can simply define a class as an injectable provider, and the framework will automatically resolve and inject the dependencies when needed. This simplifies the development process and promotes modular, reusable code. Here’s an example of injecting a service into a controller in Nest.js:

import { Injectable } from '@nestjs/common';

@Injectable()
export class MyService {
  // Service implementation
}

import { Controller, Get } from '@nestjs/common';
import { MyService } from './my.service';

@Controller('example')
export class MyController {
  constructor(private myService: MyService) {}

  @Get()
  getData() {
    return this.myService.getData();
  }
}

2. Architecture:

Express: Express is a minimalistic framework that provides flexibility in structuring your application. It does not enforce any specific architectural pattern, allowing developers to choose their preferred approach. This flexibility can be advantageous for experienced developers who want complete control over the application structure. However, it can also lead to inconsistencies and difficulties in maintaining a consistent architecture across the project.
Nest.js: Nest.js follows the MVC (Model-View-Controller) architectural pattern by default. It encourages developers to structure their applications in a modular and organized way. With Nest.js, you divide your code into modules, each containing controllers, services, and repositories. This modular approach makes the codebase more maintainable, testable, and scalable. It also helps in separating concerns and promoting code reusability.

3. Validation:

Express: Express does not have built-in support for request validation. Developers often use external libraries like Joi or celebrate to perform request validation. These libraries provide various validation rules and utilities to validate incoming requests. However, setting up and integrating these libraries into the Express application requires additional effort and configuration.
Nest.js: Nest.js provides a powerful built-in validation mechanism using decorators and the class-validator library. You can easily validate incoming requests by attaching decorators to DTO (Data Transfer Object) classes. The decorators define validation rules for each property in the DTO. When a request is received, Nest.js automatically validates the request payload based on the defined rules. This simplifies the validation process and improves code readability. Here’s an example:

import { IsString, IsNotEmpty } from 'class-validator';

export class CreateProductDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  // Other properties and validation rules
}

4. Authorization:

Express: Express does not provide built-in authorization mechanisms. Developers need to implement authorization logic manually or use third-party libraries like Passport.js. These libraries offer various authentication and authorization strategies, such as JWT (JSON Web Tokens), session-based authentication, or OAuth. Developers must configure and integrate these libraries into their Express application, which can add complexity and require additional code.
Nest.js: Nest.js offers a robust built-in authorization system using decorators and guards. Guards are responsible for protecting routes based on various conditions, such as roles or permissions. Nest.js provides different types of guards, including JWTAuthGuard, RoleGuard, and SessionAuthGuard. You can easily create custom guards to implement specific authorization logic. Guards can be applied at the controller level or specific route level using decorators. This simplifies the implementation of authorization logic and promotes code reusability. Here’s an example of a basic guard in Nest.js:

import { CanActivate, ExecutionContext } from '@nestjs/common';

export class AuthGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Authorization logic goes here
    return true; // or false based on authorization check
  }
}

5. API Documentation:

Express: Express does not have built-in support for API documentation. Developers often rely on third-party tools like Swagger or Postman to document their APIs. These tools require additional configuration and setup to generate API documentation based on routes, request/response schemas, and annotations.
Nest.js: Nest.js has built-in support for generating API documentation using OpenAPI (formerly known as Swagger). You can annotate your controllers and DTOs with decorators provided by the @nestjs/swagger package to automatically generate API documentation. These decorators allow you to specify information such as API tags, operation summaries, and response schemas. This makes it easier to maintain up-to-date documentation alongside your codebase. Developers can view and interact with the API documentation generated by Nest.js Swagger UI or integrate it with other API documentation tools. Here's an example:

import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';

@ApiTags('products')
@Controller('products')
export class ProductsController {
  @ApiOperation({ summary: 'Get all products' })
  @ApiResponse({ status: 200, description: 'Returns all products' })
  @Get()
  getAllProducts() {
    // Implementation
  }
}

6. Database:

Express: Express does not provide built-in support for database integration. Developers often choose their own database libraries or ORMs like Sequelize or Mongoose to interact with databases. These libraries help in establishing connections, executing queries, and mapping database entities to JavaScript objects. The choice of the database library depends on the specific requirements of the project.
Nest.js: Nest.js supports multiple database integration options, including popular databases like MySQL, PostgreSQL, MongoDB, and more. It provides dedicated modules and decorators for seamless integration with different databases. For example, the @nestjs/typeorm package allows you to integrate with TypeORM, a powerful ORM (Object-Relational Mapping) library. Nest.js simplifies the process of establishing database connections, defining entities, and executing queries through its module system. This enables developers to focus more on application logic rather than dealing with low-level database operations.

7. Middlewares:

Express: Express is known for its middleware-based architecture. Middlewares are functions that can be executed before or after a request is handled. Developers can define custom middleware functions or use existing middleware libraries to handle tasks like logging, error handling, authentication, etc. Middlewares in Express follow a sequential execution model, where each middleware has access to the request and response objects and can modify them or pass control to the next middleware in the chain.
Nest.js: Nest.js also supports middlewares and follows a similar middleware-based architecture as Express. It provides decorators like @Middleware() and @UseGuards() to apply middlewares at the controller or route level. Additionally, Nest.js offers built-in middlewares like LoggerMiddleware and HttpExceptionFilter for common use cases. Nest.js middlewares can be synchronous or asynchronous and can be used for tasks such as request logging, request/response modification, error handling, and more.

Express holds a significant advantage over Nest in terms of its large and active community. This means that when using Express, it is highly likely that you will find ample support, resources, and solutions for your development needs. Nest, on the other hand, is built on top of Express and can be seen as an extension or enhancement of it. As a result, Nest introduces additional complexity and more features to learn.

If we focus solely on the comparison between Express and Nest, Express is generally easier to understand and work with. However, Express alone may not be sufficient for building a comprehensive web server in most modern applications. Developers often need to incorporate additional libraries to fulfill their specific requirements, which can make the learning curve for Express unpredictable.

Therefore, while Express offers simplicity and a thriving community, it may require supplemental libraries to meet the demands of complex projects. On the other hand, Nest provides a more feature-rich and extended framework but may require a steeper learning curve due to its additional functionalities.

Attached is a table outlining the differences between express.js and Nest.js incase you’d like to skim through it and refresh your memory