Como você otimiza o desempenho do NestJS?

Question

Accepted Answer

Otimizar o desempenho do NestJS abrange a **escolha do adaptador HTTP** (Express vs Fastify), eficiência de banco de dados, cache e práticas gerais do Node.js. Como sempre: **profile para encontrar o verdadeiro gargalo** — que geralmente é o banco de dados ou I/O, não o NestJS em si.

## Mude para Fastify para maior throughput

```ts
// NestJS supports Fastify as an alternative to the default Express adapter
import { FastifyAdapter } from "@nestjs/platform-fastify";

const app = await NestFactory.create(AppModule, new FastifyAdapter());
// Fastify is significantly faster than Express (~2x in benchmarks) with the SAME NestJS code
```

Porque NestJS é **agnóstico de plataforma**, você pode trocar Express por **Fastify** — frequentemente cerca de 2x mais rápido para throughput HTTP — geralmente sem alterar o código da sua aplicação. Uma vitória fácil para APIs de alto throughput.

## O banco de dados é geralmente o verdadeiro gargalo

```ts
// ❌ N+1 queries — fetching related data in a loop (the most common perf killer)
for (const user of users) {
  user.posts = await postsRepo.findByUser(user.id);   // 1 query per user!
}

// ✅ eager load / join / batch in ONE query
const users = await usersRepo.find({ relations: ["posts"] });
```

```text
Database optimizations (the biggest real wins for most APIs):
  ✓ Fix N+1 queries (use joins/relations/DataLoader)
  ✓ Add indexes for slow queries
  ✓ Select only needed columns; paginate large result sets
  ✓ Use connection pooling
```

## Cache de operações custosas

```ts
@UseInterceptors(CacheInterceptor)   // cache read-heavy endpoints (in-memory or Redis)
// or manual caching of expensive queries/computations
```

Cache (com Redis para múltiplas instâncias) evita repetir trabalho custoso — uma das otimizações com maior impacto.

## Async/concorrência e offloading

```ts
// parallelize independent async operations
const [users, products] = await Promise.all([getUsers(), getProducts()]);

// offload heavy CPU work to a queue/worker (don't block the event loop)
await this.queue.add("process-image", data);
```

Paralelizar I/O independente com `Promise.all` e offload de trabalho intensivo em CPU para filas/workers em background para que não bloqueie o event loop single-threaded do Node.

## Outras técnicas

```text
✓ Enable compression (gzip/brotli) for responses
✓ Use streaming for large payloads/files
✓ Scale horizontally (multiple instances + load balancer; cluster/PM2)
  — keep the app STATELESS (sessions/cache in Redis, not process memory)
✓ Lazy-load modules where appropriate; minimize startup work
✓ Profile with clinic.js / node --prof to find actual hotspots
```

## Meça primeiro

```text
Don't guess. Profile (clinic.js, autocannon for load testing) to find the REAL
bottleneck — for most APIs it's the database or external I/O, not Nest/Node code.
```

## Por que isso importa

Otimização de desempenho é valiosa para construir serviços NestJS escaláveis, e entender as opções é conhecimento importante em nível sênior — mas deve ser **orientada por medição** (profiling para encontrar o verdadeiro gargalo, que para a maioria das APIs é o banco de dados ou I/O em vez do NestJS em si).

Várias técnicas específicas do NestJS e gerais importam: o **adaptador Fastify** oferece uma vitória fácil e significativa em throughput HTTP (aproximadamente 2x) graças ao NestJS ser agnóstico de plataforma, geralmente sem alterações de código; **otimizações de banco de dados** (corrigir queries N+1, indexação, paginação, pooling) entregam os maiores ganhos no mundo real, já que o banco de dados é tipicamente o verdadeiro gargalo; **cache** (em memória ou Redis) evita trabalho custoso repetido; **paralelizar** operações async independentes e **offload de trabalho intensivo em CPU para filas** mantém o event loop single-threaded do Node responsivo; e **scaling horizontal** (com uma app stateless e estado compartilhado com suporte Redis) lida com alta carga.

Conhecer esse toolkit — e especialmente a disciplina de fazer profile primeiro, focar no verdadeiro gargalo (geralmente o DB) e aplicar a correção correta em vez de adivinhar ou fazer micro-otimizações prematuras — é o que permite construir aplicações NestJS rápidas e escaláveis.

Reflexo da abordagem madura e sistemática de desempenho que distingue desenvolvedores sênior e é um tópico comum e praticamente importante para trabalho de back-end em produção.