Volver al blog
ResilienciaArquitecturaBackendBun

Caída en JPMorgan Chase: la lección de resiliencia para devs

17 de noviembre de 2026·6 min de lectura·Diego Horvatti

Un problema técnico en JPMorgan Chase ralentizó la banca en línea de otros bancos en Estados Unidos. Los clientes de esos bancos nunca abrieron una cuenta en Chase. La caída en JPMorgan Chase es una noticia de bancos, pero la lección sirve para quien escribe software: el sistema de otra empresa puede tumbar el tuyo.

El reportaje de AP menciona instituciones como Wells Fargo y Truist entre las afectadas. No voy a especular sobre la causa interna, porque eso lo sabe el equipo de Chase. Lo que interesa aquí es el patrón. Aparece cada semana en proyectos mucho más pequeños que un banco.

Qué pasó con Chase y los otros bancos

En resumen: uno de los bancos más grandes del mundo tuvo un problema técnico y la lentitud llegó a bancos de la competencia. Para el cliente final, la app abría, pero las transferencias y consultas tardaban o se quedaban colgadas.

Esto solo ocurre porque el sistema bancario es una red de dependencias. Pagos, compensación y transferencias entre instituciones pasan por puntos compartidos. Un nodo grande se atraganta y los vecinos lo sienten.

Ahora cambia "banco" por "API de pagos", "proveedor de login" o "servicio de correo transaccional". Es la misma película, con menos presupuesto.

¿Por qué una falla en un sistema tumba a otro?

Casi nunca es la falla en sí lo que tumba tu sistema. Es la forma en que tu código la espera.

El escenario clásico:

  1. Tu backend llama a una API externa.
  2. La API no se cae, se vuelve lenta. Responde en 30 segundos en lugar de 300 ms.
  3. Cada request de tu usuario mantiene una conexión abierta esperando.
  4. El pool de conexiones se llena, la memoria sube, y endpoints que ni siquiera usan esa API empiezan a fallar.

Fíjate que la API externa nunca se cayó. Solo se volvió lenta. Y la lentitud es peor que una caída, porque una caída da error al instante y la lentitud retiene recursos durante mucho tiempo.

La lentitud contagia. El error rápido, no.

Ya vi esto pasar con una pasarela de pago en un e-commerce. La pasarela empezó a responder en 40 segundos un viernes por la noche, y la página de producto, que no tenía nada que ver con pagos, se cayó con ella. El culpable era un fetch sin timeout en el checkout, ocupando todos los workers.

Timeout: la línea de código que nadie escribe

El fetch no tiene timeout por defecto. Ni en Node, ni en Bun, ni en el navegador. Si el otro lado nunca responde, tu llamada tampoco termina nunca.

La corrección cabe en una línea:

const res = await fetch('https://api.parceiro.com/saldo', {
  signal: AbortSignal.timeout(3000),
})

Tres segundos es una cifra razonable para empezar. El número correcto sale de tu p99 en producción. Si la API normalmente responde en 400 ms, esperar 30 segundos no ayuda a nadie.

Uso Bun en mis backends y la API es la misma, AbortSignal.timeout funciona igual. El runtime moderno te da la herramienta, pero no escribe la línea por ti.

Reintentar sin idempotencia es un bug con retraso

El reflejo después del timeout es "intenta de nuevo". En un banco, eso es peligroso. Si la primera solicitud de transferencia llegó al servidor pero la respuesta se perdió, el reintento transfiere dos veces.

Por eso toda API financiera seria acepta una clave de idempotencia:

const idempotencyKey = crypto.randomUUID()

async function transferir(payload: Transferencia, intentos = 3) {
  for (let i = 0; i < intentos; i++) {
    try {
      return await fetch('https://api.parceiro.com/transferencias', {
        method: 'POST',
        headers: { 'Idempotency-Key': idempotencyKey },
        body: JSON.stringify(payload),
        signal: AbortSignal.timeout(3000),
      })
    } catch {
      await Bun.sleep(2 ** i * 200 + Math.random() * 100)
    }
  }
  throw new Error('Socio no disponible')
}

Aquí importan tres detalles:

  • La clave se genera una sola vez, fuera del loop. Si generas una clave por intento, no protege nada.
  • Backoff exponencial con jitter. Si mil clientes repiten la solicitud en el mismo milisegundo, ayudas a tumbar un servicio que ya estaba mal.
  • Límite de intentos. Reintentar infinitamente es un ataque de denegación de servicio que tú mismo le haces a tu proveedor.

En PostgreSQL, la clave se convierte en una constraint UNIQUE en la tabla de operaciones. Así la base de datos garantiza que la operación ocurre una sola vez, aunque el código se equivoque.

Circuit breaker: deja de tocar la puerta

Si la dependencia falló 20 veces seguidas, la llamada 21 probablemente también va a fallar. El circuit breaker deja de llamar por un tiempo y responde con error al instante.

La versión mínima es corta:

let fallas = 0
let abiertoHasta = 0

async function llamarSocio(url: string) {
  if (Date.now() < abiertoHasta) throw new Error('Circuito abierto')
  try {
    const res = await fetch(url, { signal: AbortSignal.timeout(3000) })
    fallas = 0
    return res
  } catch (err) {
    if (++fallas >= 5) abiertoHasta = Date.now() + 30_000
    throw err
  }
}

Es estado en memoria, por instancia. Si corres diez instancias, cada una aprende por su cuenta. Para la mayoría de los proyectos, eso basta. Cuando no alcance, ahí sí vale la pena guardar el estado en Redis o usar una librería lista.

La ganancia es doble. Tu sistema deja de gastar recursos esperando, y el proveedor gana aire para recuperarse. Quien se quedó martillando una API caída sabe que suele ser parte del problema.

Qué cambia en tu flujo de trabajo

El código es la mitad de la conversación. La otra mitad es producto y operación.

Mapea tus dependencias. Haz una lista de cada API externa que llama tu app. Para cada una, responde: si se vuelve lenta durante una hora, ¿qué ve el usuario? Si la respuesta es "se congela toda la pantalla", encontraste tu próximo incidente.

Degrada con elegancia. Cuando el servicio de saldo se retrasa, la app puede mostrar el último valor en caché con un aviso de "actualizado hace 5 minutos". Eso es mucho mejor que un spinner eterno. El usuario acepta un dato un poco viejo. Lo que no acepta es una app que parece muerta.

Separa recursos. El pool de conexiones del checkout no debería ser el mismo que el de la página de producto. Cuando un compartimento se llena de agua, el barco no se hunde entero. El nombre del patrón es bulkhead.

Prueba la falla a propósito. En staging, cambia la URL del socio por un endpoint que tarde 60 segundos en responder. En diez minutos descubres si tus timeouts existen de verdad o solo existen en tu cabeza.

Un endpoint lento de prueba en Bun:

Bun.serve({
  port: 4000,
  async fetch() {
    await Bun.sleep(60_000)
    return new Response('por fin')
  },
})

Apunta la app a localhost:4000 y mira qué pasa. Es la prueba de resiliencia más barata que existe.

Mi opinión

El episodio de Chase recuerda algo incómodo: no controlas la disponibilidad de tu sistema. Solo controlas cómo reacciona cuando alguien de quien dependes falla. Y siempre falla alguien. Puede ser un banco, una nube o ese SaaS de envío de SMS que integraste en una tarde.

Mi opinión fuerte: el timeout debería ser obligatorio en todo fetch, y yo bloquearía cualquier PR sin él. Parece exagerado hasta el primer viernes por la noche en que te quedas despierto viendo los workers atascados esperando una API que nunca responde.

La buena noticia es que nada de esto exige una arquitectura sofisticada. Timeout, reintentos con idempotencia, un circuit breaker de veinte líneas y una caché para mostrar datos viejos ya cubren la mayor parte de los casos. Si quieres ver cómo aplico esto en producción, échale un vistazo a mis proyectos.

Resumen para LinkedIn

Una API lenta tumba más sistemas que una API caída.

JPMorgan Chase tuvo una falla y la banca en línea de otros bancos se volvió lenta. Los clientes de esos bancos nunca abrieron una cuenta en Chase.

En tu proyecto pasa lo mismo: la pasarela de pago empieza a responder en 40 segundos, todos los workers se quedan atascados esperando, y la página de producto se cae con ella.

El fetch no tiene timeout por defecto. Una línea con AbortSignal.timeout ya evita buena parte del daño.

Súmale reintentos con clave de idempotencia, un circuit breaker simple y caché para mostrar el último dato conocido, y cubres la mayoría de los casos.

Escribí el paso a paso con código en el blog. Quien ya pasó un viernes por la noche viendo workers bloqueados se va a sentir identificado.

#Resiliencia #DesarrolloDeSoftware #Backend #TypeScript #Ingenieria