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

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.

- URL: https://fernando.moretes.com/studies/monzo-core-bancario-em-microsservicos

- Markdown: https://fernando.moretes.com/studies/monzo-core-bancario-em-microsservicos/study.md?lang=pt

- Type: Teardown

- Company: Monzo

- Domain: Sistemas financeiros

- Date: 2016-09-19

- Tags: monzo, microservices, kubernetes, banking, network-security, kafka, linkerd, teardown

- Reading time: 7 min

---

## 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 (user)

### Kubernetes on AWS

- API edge HTTPS (edge)
- Linkerd RPC, retry, LB (network)
- Account service Go (compute)
- Ledger service Go (compute)
- Network policy who calls whom (security)

### Data and events

- Kafka async work (messaging)
- Cassandra service data (data)

### Fluxos

- app -> edge: HTTPS
- edge -> linkerd: RPC
- linkerd -> svca: roteia e balanceia
- svca -> svcb: RPC via Linkerd
- policy -> svcb: libera só chamadores declarados
- svca -> kafka: publica
- kafka -> svcb: consome
- svca -> cassandra: lê e grava
- svcb -> cassandra: lê e grava

## 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)

**Pros**
- 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

**Cons**
- 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

**Verdict:** Faz sentido sem core legado e com time de plataforma dedicado

### Monólito modular com poucos serviços de borda

**Pros**
- 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

**Cons**
- Deploy acoplado entre módulos
- Escala o conjunto, não o componente quente
- Fronteira de módulo apodrece sem disciplina de revisão

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

### Core licenciado mais serviços de canal

**Pros**
- 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

**Cons**
- Roadmap preso ao fornecedor
- Janela de batch e limite de integração do core
- Serviços de cima herdam o gargalo de baixo

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

## Leitura Well-Architected

- **security**: 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.
- **reliability**: 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.

> **O que eu faria diferente:** 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)](https://monzo.com/blog/2016/09/19/building-a-modern-bank-backend)
- [Monzo: We built network isolation for 1,500 services to make Monzo more secure](https://monzo.com/blog/we-built-network-isolation-for-1-500-services)

## Fontes do caso

- [Monzo: Building a Modern Bank Backend](https://monzo.com/blog/2016/09/19/building-a-modern-bank-backend)
- [Monzo: We built network isolation for 1,500 services to make Monzo more secure](https://monzo.com/blog/we-built-network-isolation-for-1-500-services)
