Dependency injection basics in NestJS - Performance & Optimization

Performance: Dependency injection basics

MEDIUM IMPACT

Dependency injection affects application startup time and runtime memory usage by managing how services and components are created and shared.

Creating and using services in a NestJS application

NestJS

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

@Injectable()
export class UserService {
  getUser() {
    return { id: 1, name: 'Alice' };
  }
}

import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  getUser() {
    return this.userService.getUser();
  }
}

NestJS injects a single shared instance of UserService, reducing memory and improving startup consistency.

📈 Performance GainSaves memory by reusing instances; faster startup by centralized object creation.

Creating and using services in a NestJS application

NestJS

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

@Injectable()
export class UserService {
  getUser() {
    return { id: 1, name: 'Alice' };
  }
}

// In a controller or another service
const userService = new UserService();
userService.getUser();

Manually creating service instances bypasses NestJS's dependency injection container, causing multiple instances and redundant memory use.

📉 Performance CostIncreases memory usage and can slow startup due to unmanaged object creation.

Performance Comparison

Pattern	Instance Creation	Memory Usage	Startup Time	Verdict
Manual service instantiation	Multiple instances per use	High due to duplicates	Slower due to unmanaged creation	[X] Bad
NestJS dependency injection	Single shared instance	Lower due to reuse	Faster with centralized control	[OK] Good

Rendering Pipeline

Dependency injection affects the application initialization phase by controlling how and when service instances are created and wired together before the app handles requests.

→Application Startup

→Memory Allocation

⚠️ BottleneckExcessive manual instantiation causes redundant memory allocation and slower startup.

Optimization Tips

1Always let NestJS create and manage service instances via dependency injection.

2Avoid manual 'new' calls for services to prevent redundant memory use.

3Use singleton services to improve startup speed and reduce memory footprint.

Performance Quiz - 3 Questions

What is a main performance benefit of using NestJS dependency injection for services?

A It reuses service instances to reduce memory usage.

B It delays service creation until after the first request.

C It automatically caches HTTP responses.

D It compiles services into native code.

DevTools: Node.js Inspector (or Chrome DevTools for Node)

How to check: Profile memory usage and CPU during app startup; look for multiple instances of the same service in heap snapshots.

What to look for: High memory usage or multiple identical objects indicates poor DI usage; efficient DI shows fewer instances and faster startup.