Pular para o conteúdo
fernando.moretes.com
BlogEstudosCursosE-booksOpen SourcePodcasts
Loading…
Fernando Azevedo

Arquiteto de TI Especialista

Arquitetura, AWS, IA em produção, sistemas financeiros e FinOps, escritos a partir do que foi operado, com os números.

  • LinkedIn
  • GitHub
  • E-mail

Conteúdo

  • Blog
  • Estudos de arquitetura
  • Cursos
  • E-books
  • Open Source
  • Podcasts
  • Assuntos
  • Trilhas

Ferramentas

  • Moretes Architect MCP
  • Well-Architected self-check
  • Arquitetura deste site
  • Números públicos
  • Histórico de estudo

Sobre

  • Comunidade
  • Hugging Face
  • IA Builder
  • Perfil
  • Currículo (CV)
  • Trabalhe comigo
  • Media kit
  • RSS do blog
  • RSS dos estudos
  • Artigos narrados (podcast)
  • llms.txt
  • Termos, privacidade e uso de IA

(c) 2026 Fernando Francisco Azevedo

Estudos/Teardown
RSSMarkdownLLMs
TeardownMonzoSistemas financeiros

Monzo: um banco construído do zero em microsserviços na nuvem

19 de set. de 2016 7 min Com apoio de IA000 visualizações00 reproduções

Teardown da arquitetura da Monzo a partir de dois posts de engenharia da própria empresa: a escolha de microsserviços pequenos, Kubernetes na AWS, Linkerd e Kafka em 2016, e o projeto de isolamento de rede entre cerca de 1.500 serviços anos depois. Analiso o que um core bancário ganha e paga com essa granularidade e quando eu não copiaria esse desenho num banco médio brasileiro.

Ouvir estudo

cerca de 7 min · áudio gerado ao tocar

Ficha do caso

Empresa
Monzo, banco digital de varejo do Reino Unido
Fontes
Dois posts de engenharia da própria Monzo: o de 2016 sobre o backend e o de isolamento de rede
Estilo de arquitetura
Microsserviços pequenos desde o primeiro dia, sobre infraestrutura de cluster em nuvem pública
Orquestração
Mesos/Marathon no início, depois Kubernetes na AWS
RPC
Linkerd: descoberta de serviço, balanceamento de carga e retry
Assíncrono e dados
Kafka para trabalho assíncrono; Cassandra como banco de dados
Escala de serviços
Cerca de 1.500 serviços no momento do projeto de isolamento de rede
Fora do escopo
Números de clientes, contas e volume: não estão nas fontes e não entram aqui

A Monzo decidiu em 2016 que um banco novo podia nascer como centenas de serviços pequenos rodando em cluster na nuvem, e não como um core central. Anos depois, a mesma empresa publicou como a contagem de cerca de 1.500 serviços virou um problema de segurança de rede. Lidos juntos, os dois posts são o registro mais honesto que conheço do que essa granularidade custa: o ganho aparece no primeiro ano, a conta chega aos poucos e continua chegando.

O problema: um banco sem legado, mas com regulador

Em 2016 a Monzo estava construindo um banco de varejo do zero. Isso parece vantagem, e é: não havia mainframe, não havia core de terceiros com janela de batch noturna, não havia contrato de fornecedor travando o roadmap. Mas a ausência de legado não reduz a exigência. Um banco precisa estar disponível quando o cartão passa na maquininha às 23h de sábado, não pode perder um lançamento e precisa explicar ao regulador, anos depois, por que um saldo ficou como ficou.

O raciocínio do post de 2016 é que um banco moderno não deveria repetir o desenho de sistemas grandes e centralizados que mudam devagar e falham por inteiro. A aposta foi o oposto: muitos serviços pequenos, cada um com uma responsabilidade estreita, sobre infraestrutura de cluster numa nuvem pública desde o primeiro dia. A justificativa não era moda. Era escalar horizontalmente sem redesenho, fazer deploy com frequência sem parar o banco e evitar que a falha de um componente derrube os outros.

A pergunta que me interessa não é 'microsserviços funcionam num banco?'. A Monzo responde que sim. A pergunta é: o que um core bancário passa a dever quando é dividido em centenas de processos que conversam pela rede? A resposta curta, que o próprio post antecipa, é que você troca problemas de código por problemas de sistema distribuído: RPC, descoberta de serviço, retry e consistência entre serviços. E, como o segundo post mostra, troca também por um problema de segurança que só fica visível quando a contagem passa de mil.

Por onde uma requisição passa e onde ficam as fronteiras de confiança

Reconstrução simplificada a partir dos dois posts. Os nomes 'Account service' e 'Ledger service' são ilustrativos: representam dois dos cerca de 1.500 serviços. O Linkerd faz descoberta, balanceamento e retry entre serviços; a política de rede decide quem pode chamar quem. Setas tracejadas são assíncronas (Kafka) ou de controle (a política não carrega tráfego, ela filtra).

Clients
  • Monzo app · mobile
Kubernetes on AWS
  • API edge · HTTPS
  • Linkerd · RPC, retry, LB
  • Account service · Go
  • Ledger service · Go
  • Network policy · who calls whom
Data and events
  • Kafka · async work
  • Cassandra · service data

Como o sistema funciona

Orquestração: a Monzo começou com Mesos e Marathon e migrou para Kubernetes na AWS. A troca importa menos pela ferramenta e mais pelo que ela padroniza: todo serviço vira um contêiner com o mesmo ciclo de vida, o mesmo jeito de escalar e o mesmo jeito de ser substituído quando um nó morre. Com centenas de serviços, padronização não é conforto, é a única forma de um time de plataforma acompanhar.

RPC e descoberta: cada chamada entre serviços é uma chamada de rede. O post descreve o Linkerd como a camada que resolve isso fora do código de negócio: descoberta de serviço, balanceamento entre instâncias e retry. Isso tira de cada time a tentação de escrever o próprio cliente HTTP com política de retry improvisada. Mas retry na camada de rede tem uma consequência que precisa ser dita em voz alta: ele só é seguro se a operação chamada for idempotente. Num banco, um débito repetido pelo proxy depois de um timeout é exatamente o bug que vira reclamação formal. A camada de RPC resolve o transporte; a idempotência continua sendo dever de quem escreve o handler.

Trabalho assíncrono: o que não precisa acontecer dentro da requisição vai para o Kafka. A lógica é separar o caminho crítico (autorizar, registrar) do que pode esperar alguns segundos (notificar, atualizar o feed, alimentar análises). Isso reduz a latência percebida e impede que um consumidor lento segure a transação. O preço é um estado novo, 'publicado mas ainda não processado', e alguém precisa saber quanto tempo ele pode durar antes de virar incidente.

Dados e consistência: cada serviço é dono do próprio dado, e o banco de dados citado é o Cassandra, que favorece disponibilidade e escrita distribuída em vez de transações sobre várias linhas. Não existe transação distribuída atravessando serviços. Consistência entre serviços passa a ser propriedade do desenho: chave de idempotência, ordem de eventos, trava distribuída onde a operação exige exclusividade e reconciliação para pegar o que escapou. Essa é a parte que o diagrama não mostra e a que mais pesa na manutenção. Todo fluxo financeiro novo precisa responder: o que acontece se o segundo passo falhar depois que o primeiro deu certo?

Quando 1.500 serviços viram um problema de segurança

O segundo post é o mais útil para quem opera banco, porque mostra a conta chegando. Num cluster Kubernetes sem política de rede, qualquer pod alcança qualquer outro pod. Com dez serviços isso é tolerável. Com cerca de 1.500, significa que um único serviço comprometido (uma dependência maliciosa, uma falha de desserialização, uma credencial vazada) tem caminho de rede até os serviços que movem dinheiro. O blast radius de um incidente de segurança passa a ser o cluster inteiro, e isso anula boa parte do argumento de 'falha contida' que justificou a arquitetura.

A resposta da Monzo foi impor regras de quem fala com quem. O que eu destaco não é a política de rede em si, que é recurso comum do Kubernetes. É de onde vieram as regras. Escrever 1.500 listas de permissão à mão é inviável, e lista escrita à mão apodrece no primeiro deploy. Segundo o post, o grafo de chamadas permitidas foi derivado do próprio código dos serviços, de modo que declarar uma dependência no código e liberar o tráfego na rede passam a ser a mesma ação. É a única forma de a regra continuar correta sem um time inteiro só para mantê-la.

Uma mudança dessas, num banco em produção, só é segura em etapas: descobrir o tráfego real, comparar com o que o código declara, corrigir as dependências que funcionavam por acaso e só então negar por padrão. Toda chamada não declarada que passava despercebida vira indisponibilidade no dia em que o default vira deny.

A lição dura: isolamento de rede feito depois é muito mais caro que isolamento de rede desde o início, porque o trabalho real não é escrever a regra, é descobrir as dependências que ninguém documentou. Quem nasce com default deny paga esse custo em parcelas pequenas, uma a cada serviço novo. Quem nasce aberto paga tudo de uma vez, anos depois, com o banco no ar.

Os trade-offs de granularidade para um core bancário

Microsserviços pequenos desde o dia 1 (desenho da Monzo)

Prós
  • Deploy independente por serviço, sem janela de manutenção do banco inteiro
  • Falha funcional de um serviço não derruba os outros
  • Escala horizontal por componente, só onde há carga
Contras
  • Idempotência e consistência viram dever de todo handler
  • Tracing, alarme e dashboard custam por serviço
  • Rede plana vira caminho de movimento lateral até existir default deny

Faz sentido sem core legado e com time de plataforma dedicado

Monólito modular com poucos serviços de borda

Prós
  • Transação local dentro do domínio, sem consistência construída à mão
  • Uma superfície para observar, auditar e explicar ao regulador
  • Operável por um time pequeno
Contras
  • Deploy acoplado entre módulos
  • Escala o conjunto, não o componente quente
  • Fronteira de módulo apodrece sem disciplina de revisão

Meu ponto de partida para banco médio com time pequeno

Core licenciado mais serviços de canal

Prós
  • Razão contábil e regras regulatórias de fornecedor maduro
  • Time concentrado em canal e experiência
  • Menos código próprio para auditar
Contras
  • Roadmap preso ao fornecedor
  • Janela de batch e limite de integração do core
  • Serviços de cima herdam o gargalo de baixo

Realista para quem já tem core legado; isole o core atrás de uma camada estreita

Leitura Well-Architected

Segurança

O ponto fraco que a própria Monzo expôs foi a rede plana entre cerca de 1.500 serviços. A correção, regras de quem fala com quem derivadas do código, é o padrão que eu recomendo; o certo é nascer com default deny. Complemente com identidade e segredo por serviço, nunca por cluster.

Confiabilidade

Ganho real: falha de um serviço fica contida e o Kubernetes substitui instância morta. Risco real: retry automático no Linkerd amplifica carga sobre um serviço já degradado e repete operação não idempotente. Exija chave de idempotência em toda escrita financeira e limite o orçamento de retry.

FA
O que eu faria diferente
Arquiteto de TI Especialista

Se eu começasse um banco hoje com a liberdade que a Monzo teve, copiaria três decisões e mudaria duas. Copiaria a infraestrutura de cluster padronizada desde o primeiro dia, o RPC com retry e balanceamento fora do código de negócio e o Kafka separando o caminho crítico do trabalho que pode esperar. Mudaria, primeiro, a granularidade: começaria com serviços do tamanho de um domínio (contas, pagamentos, cartões, razão) e só quebraria quando houvesse motivo medido, como time diferente, perfil de escala diferente ou requisito de isolamento. Segundo, a rede: default deny e grafo de dependências gerado do código no primeiro serviço, não no milésimo. O post de isolamento mostra que fazer isso depois é um projeto inteiro de engenharia; fazer no começo é uma linha no template do serviço.

Quando eu não copiaria esse desenho num banco médio brasileiro

Use o desenho da Monzo quando: você começa sem core legado, tem um time de plataforma dedicado que trata Kubernetes, malha de RPC e pipeline de deploy como produto, e consegue impor desde o primeiro serviço idempotência, propriedade de dado e default deny na rede. Fora disso, há três cenários em que eu não copiaria.

Time pequeno: com 15 ou 20 engenheiros, centenas de serviços significam vários serviços por pessoa (conta aproximada, minha). Cada um tem pipeline, alarme, dashboard, dependências para atualizar e regra de rede. O custo não é o de construir o serviço, é o de mantê-lo vivo por anos. Um monólito modular com fronteiras de domínio explícitas entrega quase todo o ganho de organização com uma fração da superfície operacional.

Core legado: se o razão contábil vive num core de fornecedor ou num mainframe, quebrar a camada de cima em centenas de serviços não remove o gargalo; ele só passa a receber chamadas de mais clientes. Aqui eu desenharia uma camada de integração estreita, com poucos serviços de domínio e eventos publicados a partir do core, antes de pensar em granularidade fina.

Regulador exigindo rastreabilidade: a Resolução CMN 4.893 pede política de segurança cibernética, registro e tratamento de incidentes e controle sobre os serviços de nuvem contratados. Reconstruir uma transação que atravessou vinte serviços, um tópico Kafka e um retry automático exige tracing distribuído com correlação ponta a ponta, retenção de log alinhada à política e capacidade de reconstruir estado. Dá para fazer, mas é um projeto em si, e ele precisa estar pronto antes de o primeiro auditor perguntar.

Veredito

A arquitetura da Monzo é coerente com o problema que ela tinha: um banco sem legado, com time de plataforma forte e disposição para pagar o custo de sistema distribuído em troca de deploy independente e falha contida. O que os dois posts mostram juntos é que esse custo não se paga uma vez só. Ele volta como idempotência obrigatória em cada handler, como consistência construída à mão entre serviços e, com cerca de 1.500 serviços, como um problema de segurança de rede que pediu um projeto próprio. Para um banco médio brasileiro com time pequeno, core legado e exigência de rastreabilidade da 4.893, minha recomendação é um monólito modular ou poucos serviços por domínio, com eventos e default deny desde o início. A granularidade fina da Monzo é consequência da escala e do time dela, não ponto de partida.

Referências

Monzo: Building a Modern Bank Backend (2016)Monzo: We built network isolation for 1,500 services to make Monzo more secure
#monzo#microservices#kubernetes#banking#network-security#kafka#linkerd#teardown
Fontes do caso
Monzo: Building a Modern Bank BackendMonzo: We built network isolation for 1,500 services to make Monzo more secure
Compartilhar:LinkedInWhatsAppXBaixar em Markdown
Escrito com apoio de IA a partir do caso público e da minha leitura como arquiteto.
Próximo passo
Trilha Arquiteto de IA, gratuitaFundamentos, LLMs, RAG, tools, MCP e arquitetura na AWS, em aulas curtas e interativas.Começar a trilhaAgentes de IA em produção na AWSComo eu desenho, oriento e audito agentes que vão ao ar, com os números e as fontes.Ver o IA Builder

Continue lendo

TeardownKafka em Escala: Tiered Storage, KRaft e Exactly-OnceUma análise aprofundada da arquitetura interna do Apache Kafka, modelo de log/segmentos, eliminação do ZooKeeper via KRaft, offload de dados para S3 com Tiered Storage, semântica exactly-once e o que o Amazon MSK abstrai (e o que ele não abstrai). Um teardown técnico para quem precisa operar Kafka de verdade.Ler TeardownNetflix: Chaos Engineering e Resiliência por DesignUma reconstrução arquitetural de como a Netflix transformou falhas inevitáveis em prática deliberada, da Simian Army ao failover regional automatizado. Este teardown examina as decisões técnicas, os trade-offs reais e o que separa resiliência de verdade de alta disponibilidade cosmética.Ler TeardownUber DOMA: Como Camadas de Domínio Domaram a Explosão de MicrosserviçosCom mais de 2.200 microsserviços e dependências cruzadas incontroláveis, a Uber enfrentava um problema clássico de escala organizacional disfarçado de problema técnico. A resposta foi DOMA: Domain-Oriented Microservice Architecture, uma abordagem que agrupa serviços em domínios, expõe interfaces bem definidas e introduz camadas de abstração para recuperar a coesão perdida. Este teardown reconstrói a arquitetura, analisa as decisões e aponta o que eu faria diferente.Ler
AnteriorKnight Capital (2012): US$440M em 45 minutos por um deploy parcialPróximoStripe: Design de API e Chaves de Idempotência
Gostou deste estudo? Receba o próximo.

Post-mortems, ADRs e deep dives de arquitetura no seu email, do jeito que um arquiteto lê.

Sem spam · cancele quando quiser

Pergunte ao Fernando sobre isto

Uma resposta focada sobre este estudo, do meu assistente de IA, baseada no meu trabalho.

Participe da conversa

Entre para comentar

Confirme seu e-mail para participar, você também recebe a newsletter. Sem senha.

Neste estudo
O problema: um banco sem legado, mas com reguladorArquiteturaComo o sistema funcionaQuando 1.500 serviços viram um problema de segurançaOs trade-offs de granularidade para um core bancárioWell-ArchitectedQuando eu não copiaria esse desenho num banco médio brasileiroVereditoReferências