Voltar para o blog
ResiliênciaArquiteturaBackendBun

Pane no JPMorgan Chase: a lição de resiliência para devs

17 de novembro de 2026·6 min de leitura·Diego Horvatti

Um problema técnico no JPMorgan Chase deixou lento o internet banking de outros bancos nos Estados Unidos. Os clientes desses bancos nunca abriram uma conta no Chase. A pane no JPMorgan Chase é notícia de banco, mas a lição serve para quem escreve software: o sistema de outra empresa pode derrubar o seu.

A reportagem da AP cita instituições como Wells Fargo e Truist entre as afetadas. Não vou especular sobre a causa interna, porque quem sabe é o time do Chase. O que interessa aqui é o padrão. Ele aparece toda semana em projetos bem menores que um banco.

O que aconteceu com o Chase e os outros bancos

Resumo: um dos maiores bancos do mundo teve um problema técnico e a lentidão chegou a bancos concorrentes. Para o cliente final, o app abria, mas transferências e consultas demoravam ou travavam.

Isso só acontece porque o sistema bancário é uma rede de dependências. Pagamentos, compensação e transferências entre instituições passam por pontos compartilhados. Um nó grande engasga e os vizinhos sentem.

Agora troque "banco" por "API de pagamento", "provedor de login" ou "serviço de e-mail transacional". É o mesmo filme, com orçamento menor.

Por que uma falha em um sistema derruba outro?

Quase nunca é a falha em si que derruba o seu sistema. É o jeito como o seu código espera por ela.

O cenário clássico:

  1. Seu backend chama uma API externa.
  2. A API não cai, fica lenta. Responde em 30 segundos em vez de 300 ms.
  3. Cada request do seu usuário segura uma conexão aberta esperando.
  4. O pool de conexões enche, a memória sobe, e endpoints que nem usam aquela API começam a falhar.

Repare que a API externa nunca saiu do ar. Ela só ficou lenta. E lentidão é pior que queda, porque uma queda dá erro na hora e a lentidão segura recurso por muito tempo.

Lentidão contamina. Erro rápido, não.

Já vi isso acontecer com um gateway de pagamento num e-commerce. O gateway passou a responder em 40 segundos numa sexta à noite, e a página de produto, que não tinha nada a ver com pagamento, caiu junto. O culpado era um fetch sem timeout no checkout, ocupando todos os workers.

Timeout: a linha de código que ninguém escreve

O fetch não tem timeout por padrão. Nem no Node, nem no Bun, nem no navegador. Se o outro lado nunca responder, sua chamada também nunca termina.

A correção cabe em uma linha:

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

Três segundos é um chute razoável para começar. O número certo vem do seu p99 em produção. Se a API normalmente responde em 400 ms, esperar 30 segundos não ajuda ninguém.

Uso Bun nos meus backends e a API é a mesma, AbortSignal.timeout funciona igual. O runtime moderno te dá a ferramenta, mas não escreve a linha por você.

Retry sem idempotência é bug com atraso

O reflexo depois do timeout é "tenta de novo". Em banco, isso é perigoso. Se o primeiro pedido de transferência chegou ao servidor mas a resposta se perdeu, o retry transfere duas vezes.

Por isso API financeira séria aceita uma chave de idempotência:

const idempotencyKey = crypto.randomUUID()

async function transferir(payload: Transferencia, tentativas = 3) {
  for (let i = 0; i < tentativas; 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('Parceiro indisponível')
}

Três detalhes importam aqui:

  • A chave é gerada uma vez só, fora do loop. Se você gerar uma chave por tentativa, ela não protege nada.
  • Backoff exponencial com jitter. Se mil clientes repetem o pedido no mesmo milissegundo, você ajuda a derrubar o serviço que já estava mal.
  • Limite de tentativas. Retry infinito é um ataque de negação de serviço que você faz contra o seu fornecedor.

No PostgreSQL, a chave vira uma constraint UNIQUE na tabela de operações. Assim o banco garante que a operação acontece uma vez só, mesmo que o código erre.

Circuit breaker: pare de bater na porta

Se a dependência falhou 20 vezes seguidas, a 21ª chamada provavelmente vai falhar também. O circuit breaker para de chamar por um tempo e responde erro na hora.

A versão mínima é curta:

let falhas = 0
let abertoAte = 0

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

É estado em memória, por instância. Se você roda dez instâncias, cada uma aprende sozinha. Para a maioria dos projetos isso basta. Quando não bastar, aí sim vale guardar o estado no Redis ou usar uma biblioteca pronta.

O ganho é duplo. Seu sistema para de gastar recurso esperando, e o fornecedor ganha fôlego para se recuperar. Quem ficou martelando uma API caída sabe que costuma ser parte do problema.

O que muda no seu fluxo de trabalho

Código é metade da conversa. A outra metade é produto e operação.

Mapeie suas dependências. Liste toda API externa que o seu app chama. Para cada uma, responda: se ela ficar lenta por uma hora, o que o usuário vê? Se a resposta for "a tela inteira trava", você achou o próximo incidente.

Degrade com elegância. Quando o serviço de saldo atrasa, o app pode mostrar o último valor em cache com um aviso de "atualizado há 5 minutos". Isso é bem melhor que um spinner eterno. O usuário aceita dado um pouco velho. O que ele não aceita é um app que parece morto.

Separe recursos. O pool de conexões do checkout não deveria ser o mesmo da página de produto. Quando um compartimento enche de água, o navio não afunda inteiro. O nome do padrão é bulkhead.

Teste a falha de propósito. Em staging, troque a URL do parceiro por um endpoint que demora 60 segundos para responder. Em dez minutos você descobre se os seus timeouts existem mesmo ou se só existem na sua cabeça.

Um endpoint lento de teste em Bun:

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

Aponte o app para localhost:4000 e veja o que acontece. É o teste de resiliência mais barato que existe.

Minha opinião

O episódio do Chase lembra uma coisa desconfortável: você não controla a disponibilidade do seu sistema. Controla só como ele reage quando alguém de quem você depende falha. E alguém sempre falha. Pode ser um banco, uma cloud ou aquele SaaS de envio de SMS que você integrou numa tarde.

Minha opinião forte: timeout deveria ser obrigatório em todo fetch, e eu bloquearia PR sem ele. Parece exagero até a primeira sexta à noite em que você fica acordado vendo os workers presos esperando uma API que nunca responde.

A boa notícia é que nada disso exige arquitetura sofisticada. Timeout, retry com idempotência, um circuit breaker de vinte linhas e um cache para mostrar dado velho já cobrem a maior parte dos casos. Se quiser ver como aplico isso em produção, dá uma olhada nos meus projetos.

Resumo para o LinkedIn

Uma API lenta derruba mais sistema do que uma API fora do ar.

O JPMorgan Chase teve uma pane e o internet banking de outros bancos ficou lento. Os clientes desses bancos nunca abriram conta no Chase.

No seu projeto o cenário é o mesmo: o gateway de pagamento passa a responder em 40 segundos, os workers ficam todos presos esperando, e a página de produto cai junto.

O fetch não tem timeout por padrão. Uma linha com AbortSignal.timeout já evita boa parte do estrago.

Junte isso com retry com chave de idempotência, um circuit breaker simples e cache para mostrar o último dado conhecido, e você cobre a maioria dos casos.

Escrevi o passo a passo com código no blog. Quem já passou uma sexta à noite vendo worker travado vai se identificar.

#Resiliencia #DesenvolvimentoDeSoftware #Backend #TypeScript #Engenharia