¿Cómo optimizas el rendimiento de NestJS?

Question

Accepted Answer

Optimizar el rendimiento de NestJS abarca la **elección del adaptador HTTP** (Express vs Fastify), eficiencia de base de datos, caching y prácticas generales de Node.js. Como siempre: **perfila para encontrar el verdadero cuello de botella** — que usualmente es la base de datos o I/O, no NestJS en sí.

## Cambia a Fastify para mayor rendimiento

```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
```

Dado que NestJS es **agnóstico de plataforma**, puedes cambiar Express por **Fastify** — a menudo aproximadamente 2x más rápido para el rendimiento HTTP — usualmente sin cambiar el código de tu aplicación. Una victoria fácil para APIs de alto rendimiento.

## La base de datos es usualmente el verdadero cuello de botella

```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
```

## Caching de operaciones costosas

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

El caching (con Redis para múltiples instancias) evita repetir trabajo costoso — una de las optimizaciones de mayor impacto.

## Async/concurrencia y 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);
```

Paraleliza I/O independiente con `Promise.all`, y delega trabajo intensivo en CPU a colas/workers en segundo plano para que no bloquee el event loop single-threaded de Node.

## Otras 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
```

## Mide primero

```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 qué es importante

La optimización de rendimiento es valiosa para construir servicios NestJS escalables, y entender las opciones es conocimiento importante de nivel senior — pero debe ser **impulsado por medición** (profiling para encontrar el verdadero cuello de botella, que para la mayoría de APIs es la base de datos o I/O en lugar de NestJS en sí).

Varias técnicas específicas de NestJS y generales importan: el **adaptador Fastify** ofrece una victoria HTTP-throughput fácil y significativa (aproximadamente 2x) gracias a que NestJS es agnóstico de plataforma, usualmente sin cambios de código; las **optimizaciones de base de datos** (resolver queries N+1, indexing, paginación, pooling) entregan las ganancias más grandes en el mundo real ya que la base de datos es típicamente el verdadero cuello de botella; el **caching** (en memoria o Redis) evita trabajo caro repetido; **paralelizar** operaciones async independientes y **delegar trabajo CPU-intensivo a colas** mantiene el event loop single-threaded de Node responsivo; y el **escalado horizontal** (con una app stateless y estado compartido respaldado por Redis) maneja carga alta.

Conocer este conjunto de herramientas — y especialmente la disciplina de perfilar primero, dirigirse al verdadero cuello de botella (usualmente la BD), y aplicar la solución correcta en lugar de adivinar u optimizar prematuramente — es lo que te permite construir aplicaciones NestJS rápidas y escalables.

Refleja el enfoque maduro y sistemático del rendimiento que distingue a los desarrolladores senior y es un tema común y prácticamente importante para trabajo backend en producción.