Desarrollo22 de agosto de 20248 min de lectura#nextjs#architecture#performance

Construyendo Sistemas Resilientes con Next.js

Mejores prácticas para garantizar alta disponibilidad y rendimiento en aplicaciones web modernas.

TL;DR5
  1. Arquitectura antes que herramientas: la resiliencia es una propiedad del diseño
  2. ISR con stale-while-revalidate mantiene las páginas vivas durante caídas del backend
  3. Los reintentos necesitan backoff y jitter — los circuit breakers cortan fallos en cascada
  4. Los error boundaries aíslan fallos en el widget que se rompió, no en la página
  5. El fallback UI y la tolerancia offline son features de primera clase, no parches
Construyendo Sistemas Resilientes con Next.js

Arquitectura Primero

Next.js suele ser la columna vertebral de las aplicaciones web modernas. Garantizar la resiliencia requiere una mezcla de buenas decisiones arquitectónicas y herramientas adecuadas.

Aprovechando Server Components y error boundaries bien implementados, puedes construir aplicaciones web extremadamente resilientes que degradan con elegancia en lugar de colapsar por completo.

Static Generation vs SSR

Siempre que sea posible, usa Incremental Static Regeneration (ISR) por defecto. Esto garantiza que, aunque tus APIs backend estén temporalmente caídas, los usuarios seguirán viendo la última versión compilada con éxito.

Pero el tradeoff es real: ISR te da resiliencia a costa de frescura. SSR te da frescura a costa de una dependencia dura del backend.

// app/blog/[slug]/page.tsx
export const revalidate = 300; // 5 minutos

export default async function Post({ params }) {
  const post = await fetchPost(params.slug); // cacheado + revalidado
  return <Article post={post} />;
}

Cuando mi API de origen cayó 40 minutos durante un incidente de Cloudflare el año pasado, todas las páginas ISR de y7.hk siguieron sirviendo HTML viejo-pero-válido. Las páginas SSR del mismo sitio devolvieron 500. Ese experimento me costó un 4% del tráfico mensual — y cambió para siempre cómo pienso en la estrategia de renderizado.

Regla general: ISR para todo lo que pueda tener 5–60 minutos de antigüedad (posts de blog, páginas de producto, marketing). SSR solo cuando los datos viejos rompen el producto (dashboards en vivo, estado de auth, datos en tiempo real).

Los Error Boundaries son Mamparos

Sin boundaries, un solo widget que falla tira toda la página. Con boundaries, cada sección falla independientemente.

// app/components/Section.tsx
'use client';
import { Component, ReactNode } from 'react';

export class Section extends Component<
  { children: ReactNode; fallback?: ReactNode },
  { hasError: boolean }
> {
  state = { hasError: false };

  static getDerivedStateFromError() {
    return { hasError: true };
  }

  render() {
    if (this.state.hasError) {
      return this.props.fallback ?? <div className="opacity-50">Sección no disponible</div>;
    }
    return this.props.children;
  }
}

Envuelve cada unidad independiente — widgets del sidebar, secciones de comentarios, dashboards de analítica — en su propio boundary. El usuario ve una caja gris donde estaba el widget, no una pantalla en blanco.

Aprendí esto por las malas en un dashboard Web3 donde un solo timeout de RPC tumbó toda la vista del portfolio. Un boundary alrededor del ticker de precios habría salvado la sesión.

Los Reintentos Necesitan Backoff

Los reintentos ciegos amplifican los fallos. El backoff exponencial con jitter distribuye la carga y le da al upstream espacio para recuperarse.

async function fetchWithRetry<T>(
  fn: () => Promise<T>,
  attempts = 3,
  baseDelay = 300
): Promise<T> {
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      if (i === attempts - 1) throw err;
      const jitter = Math.random() * baseDelay;
      await new Promise(r => setTimeout(r, baseDelay * 2 ** i + jitter));
    }
  }
  throw new Error('unreachable');
}

Dos reglas que sigo:

  1. Nunca reintentar 4xx. Un 404 no se convierte en 200 con un retry.
  2. Limitar la espera total. Si el usuario lleva 8+ segundos mirando un spinner, muestra el fallback UI y déjalo continuar.

Los Circuit Breakers Cortan Fallos en Cascada

Los reintentos resuelven errores transitorios. Los circuit breakers resuelven errores persistentes. Si tu backend lleva 30 segundos fallando, deja de golpearlo — abre el circuito y sirve respuestas degradadas inmediatamente.

class Breaker {
  private failures = 0;
  private openUntil = 0;
  constructor(private threshold = 5, private cooldown = 30_000) {}

  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (Date.now() < this.openUntil) throw new Error('Circuit open');
    try {
      const result = await fn();
      this.failures = 0;
      return result;
    } catch (e) {
      if (++this.failures >= this.threshold) {
        this.openUntil = Date.now() + this.cooldown;
      }
      throw e;
    }
  }
}

Sin un breaker, un upstream lento se convierte en una flota de procesos Node colgados. Con uno, obtienes fallos rápidos y un sistema que se recupera en cuanto el upstream vuelve.

Edge Caching con stale-while-revalidate

El header Cache-Control es la capa de resiliencia más barata que tienes. stale-while-revalidate permite al edge servir la última copia en caché mientras obtiene una fresca en background.

Cache-Control: public, s-maxage=60, stale-while-revalidate=600

Esta es la diferencia entre “la API está caída, el sitio está caído” y “la API está caída, algunos usuarios ven datos de hasta 10 minutos de antigüedad”.

Fallback UI como Feature

Los fallbacks no son lo que muestras cuando algo se rompe — son parte del diseño. Toda sección asíncrona tiene tres estados:

  • Loading: skeleton que coincide con el layout final (sin layout shift).
  • Success: el contenido real.
  • Error: una versión degradada que aún permite al usuario trabajar.

Si tu widget de precios falla, no muestres un error rojo — muestra los últimos precios cacheados con un badge pequeño de “actualizado hace 12 min”. Si el sistema de comentarios falla, muestra el hilo de solo lectura y oculta el input.

Tolerancia Offline

Los Service Workers no son solo para PWAs. Un SW mínimo que cachea el app shell y las últimas 5 páginas visitadas te da tolerancia offline real en wifi de hotel inestable y a 10.000 metros de altura — lo cual, si eres yo, es un porcentaje no trivial de tu navegación.

// sw.ts — cache-first para estáticos, network-first para páginas
self.addEventListener('fetch', (e) => {
  const url = new URL(e.request.url);
  if (url.pathname.startsWith('/_next/static/')) {
    e.respondWith(caches.match(e.request).then(r => r ?? fetch(e.request)));
  }
});

Fallos Reales que He Sufrido

  • Caída de Cloudflare edge KV: toda página que dependía de KV devolvió 500. Las páginas ISR sobrevivieron.
  • El CMS upstream me rate-limiteó durante un pico de tráfico. No tenía breaker; Next.js siguió golpeando el CMS hasta que recibí un IP ban duro. Ahora toda llamada externa pasa por un breaker con cooldown de 30s.
  • Un solo <PriceTicker> tumbó todo el dashboard cuando el WebSocket se cayó. Después de añadir un boundary, el resto de la UI siguió viva mientras el ticker se reconectaba en silencio.

Checklist de Resiliencia

  • ISR/SSG para contenido que tolera 5+ minutos de antigüedad
  • stale-while-revalidate en toda ruta cacheable
  • Error boundary alrededor de todo widget independiente
  • Backoff exponencial + jitter en retries; nunca reintentar 4xx
  • Circuit breaker en toda llamada a servicio externo
  • Skeleton + fallback + estado de error para toda UI async
  • Service worker cacheando el app shell
  • Kill-switch documentado para features no críticos (analítica, recomendaciones)

El Punto

La resiliencia no es una feature que se atornilla al final. Es la arquitectura misma. Cada capa — renderizado, caché, fetching, UI — tiene su modo de fallo diseñado desde el inicio. Constrúyelos temprano, y los incidentes que habrían sido outages se convierten en degradaciones silenciosas que nadie nota.

Video de avatar animado
Yakushev Hermann
Fundador visionario · Arquitecto Senior de IA agéntica · Networking

Más del blog

Anatomía de un artículo de ingeniería moderno en y7.hk

Prueba de estrés del motor de lectura y7: callouts, bloques diff, fórmulas KaTeX, video avatar circular, galería de figures, spoilers y un selector de fuente.

15 oct 2026 · 5 min de lectura

Viviendo entre husos horarios

Lo que 67 países y cuatro bases te enseñan sobre el trabajo profundo, el jet lag y construir productos que nadie te pidió.

18 jul 2026 · 6 min de lectura