Monolito modular pode ser a escolha certa quando microsserviços custam mais do que resolvem. Por anos, a resposta padrão para times que cresciam foi migrar para microsserviços. Hoje, mais empresas revisam essa escolha, porque o custo de operação cresceu junto com o número de serviços.
Esse foi o tema central do episódio #293 do nosso podcast Entre Chaves.
Por que microsserviços deixaram de ser a escolha óbvia
Microsserviços resolvem um problema real: equipes grandes demais para um único repositório, deployando no mesmo ritmo. Por isso, a arquitetura virou padrão de mercado na década passada. Praticamente todo time que queria parecer moderno migrava para serviços, mesmo sem o problema de escala que justificava essa escolha.
Só que esse ganho tem um preço. Cada serviço novo soma rede, versionamento de contrato, monitoramento e um pipeline próprio. Com isso, times pequenos acabam pagando o custo de operação de uma arquitetura pensada para times grandes. O resultado é velocidade menor, não maior, exatamente o oposto do que a decisão deveria entregar.
O custo que só aparece depois
Além disso, esse custo não aparece de uma vez. Ele se acumula aos poucos, serviço após serviço, até que ninguém mais lembra por que determinado componente virou um serviço separado em primeiro lugar. Em vários casos, a decisão original fazia sentido para o contexto daquele momento. O problema é que ninguém revisita essa decisão depois, mesmo quando o contexto muda e o custo deixa de compensar o benefício original.
Monolito modular resolve o mesmo problema sem o mesmo custo?
Monolito modular resolve, sim, boa parte do mesmo problema, mas com menos peças móveis. Ele organiza o código em módulos com fronteiras claras, dentro de um único processo de deploy, em vez de espalhar essas fronteiras em serviços de rede separados.
Na prática, isso significa manter a disciplina de separar responsabilidades, só que sem pagar o custo de rede, observabilidade distribuída e versionamento entre serviços. Por isso, times menores ou times no início de um produto costumam ganhar mais com essa abordagem.
Vale notar que monolito modular não é sinônimo de monolito desorganizado. A diferença central está exatamente nas fronteiras internas. Um monolito modular bem construído separa domínios com a mesma disciplina que microsserviços exigiriam. A diferença é que ele faz isso sem o custo de rede entre eles.
O papel da Lei de Conway nessa decisão
A Lei de Conway diz que a arquitetura de um sistema tende a copiar a estrutura de comunicação da organização que o constrói. Ou seja, se os times não têm fronteiras claras entre si, migrar para microsserviços não resolve o problema, só move a confusão para dentro da rede.
Por isso, antes de separar módulos em serviços, faz sentido perguntar se a organização já tem fronteiras de responsabilidade bem definidas. Sem isso, qualquer arquitetura, modular ou distribuída, tende a repetir o mesmo acoplamento, só que em lugares diferentes.
Essa pergunta costuma expor um problema organizacional disfarçado de problema técnico. Times sem dono claro para um domínio de negócio tendem a produzir código acoplado, independentemente de quantos serviços esse código seja dividido entre.
Um exemplo de atrito que a arquitetura não resolve
Duas equipes que discutem toda mudança de contrato entre si numa reunião semanal ilustram bem esse ponto. Esse atrito segue para dentro do código, esteja ele organizado como monolito modular ou como microsserviços. Resolver a fronteira organizacional primeiro costuma valer mais do que escolher a arquitetura certa.
O custo invisível da transação distribuída
Transação distribuída é um dos custos que menos aparece na decisão inicial e mais pesa depois. Dentro de um monolito, uma operação que envolve várias tabelas costuma rodar em uma única transação de banco. Entre serviços, essa garantia desaparece.
Como resultado, o time precisa lidar com consistência eventual, compensação de falhas e reconciliação de dados entre serviços. Isso não é impossível, mas exige maturidade de engenharia que poucos times têm quando fazem a escolha.
Observabilidade fica mais cara em microsserviços
Além disso, rastrear um erro que passa por cinco serviços custa mais caro do que rastrear um erro dentro de um único processo. Sem tracing distribuído bem implementado, um incidente simples vira uma investigação longa. Afinal, ninguém enxerga o caminho completo da requisição sem essa instrumentação.
Em um monolito modular, por outro lado, o mesmo erro aparece numa única stack trace, dentro do mesmo processo. Isso reduz bastante o tempo até encontrar a causa raiz.
Fitness functions: como manter fronteiras saudáveis dentro do monolito
Fitness function é um teste automatizado que verifica se a arquitetura continua alinhada a um objetivo arquitetural, não a um resultado de negócio. A ideia, trata atributos como acoplamento e organização do código da mesma forma que o TDD trata regras de negócio. Ou seja, com teste automatizado rodando no pipeline, não com revisão manual esporádica.
Esse tipo de verificação já aparece em relatos internos de operação de engenharia. Um exemplo é o critério de harnessability descrito pela dti. Ele também usa sensores automatizados para checar a qualidade de um repositório. Nesse caso, o sensor avalia se há testes e regras de negócio explícitas o suficiente antes de liberar mais autonomia para um agente de IA operar ali.
ArchUnit e Packwerk na prática
ArchUnit, para Java, e Packwerk, para Ruby, automatizam exatamente esse tipo de verificação. Eles checam, a cada build, se um módulo está importando algo de outro módulo que deveria ser privado. Dessa forma, a fronteira entre módulos deixa de depender só da disciplina da equipe. Ela passa a ser verificada por máquina, antes do merge.
Quando um módulo sai do monolito modular e vira serviço
Nem todo módulo precisa virar serviço separado. Três critérios ajudam a decidir quando vale a pena pagar o custo de separar.
O primeiro é escala independente: o módulo recebe uma carga muito maior do que o resto do sistema, e escalar tudo junto desperdiça recurso. O segundo é time dedicado: existe uma equipe inteira focada só naquele domínio, com ritmo de deploy próprio. O terceiro é isolamento de risco: uma falha nesse módulo não pode derrubar o resto do sistema.
Quando nenhum desses três critérios está presente, separar o módulo tende a aumentar custo sem aumentar benefício real. Nesse caso, o módulo continua mais seguro dentro do monolito modular, esperando o momento em que algum desses critérios realmente aparecer.
Um exemplo concreto dessa decisão
Um módulo de catálogo de produtos recebe o mesmo volume de acesso do resto do sistema. Um time que também cuida de outras partes do produto mantém esse módulo. Nesse caso, ele dificilmente justifica virar serviço. Já um módulo de processamento de pagamento, com pico de tráfego muito maior em datas específicas e exigências regulatórias próprias, costuma atender aos três critérios ao mesmo tempo.
Como migrar aos poucos, sem big bang
Trocar toda uma arquitetura de uma vez raramente funciona. O risco é alto, o tempo de entrega sobe, e usuários não esperam o sistema parado enquanto a reescrita acontece. Isso vale tanto para quem sai de um monolito desorganizado quanto para quem volta de microsserviços para um monolito modular.
O papel do Strangler Fig nessa migração
Strangler Fig é o padrão que resolve isso de forma gradual. A ideia, descrita por Martin Fowler, veio de uma observação sobre a natureza. Figueiras crescem ao redor de uma árvore hospedeira. Elas absorvem os nutrientes dessa árvore aos poucos e, no fim, sustentam sozinhas a estrutura que a árvore original ocupava.
Aplicado a sistemas, isso significa identificar pontos de costura no código legado. Depois, o time move um comportamento de cada vez para a nova estrutura. As duas versões coexistem durante toda a transição. Assim, cada módulo migrado já entrega valor, em vez de esperar o projeto inteiro terminar para ser útil.
Quais são os principais riscos de cada caminho
Microsserviços cedo demais trazem custo de operação antes de qualquer ganho real de escala. Monolito modular aplicado sem disciplina também falha, por outro lado. Sem fitness functions ou revisão de arquitetura, os módulos voltam a se acoplar. Com isso, o time perde exatamente a vantagem que buscava ao adotar essa abordagem.
Por isso, a decisão não é entre bom e ruim. É entre qual conjunto de custos a organização está preparada para pagar agora, e qual ela só vai precisar pagar depois, se crescer o suficiente para isso.
Como identificar qual risco já está em curso
Um sinal de alerta ajuda a identificar qual risco já está em curso. Deploys que ficam mais lentos a cada novo serviço apontam para o primeiro risco. O mesmo vale para incidentes cuja causa raiz leva dias para ser encontrada. Times que revisam o mesmo trecho de código em reuniões recorrentes, sem conseguir isolar responsabilidades, apontam para o segundo.
O que isso significa para produtividade e qualidade técnica
Escolher entre microsserviços e monolito modular não é uma decisão definitiva nem ideológica. É uma decisão sobre em que momento do crescimento do time e do produto cada custo compensa.
Times que tratam essa escolha como critério técnico, não como tendência de mercado, tendem a manter a arquitetura simples pelo tempo que ela ainda resolve o problema. Além disso, quando chega a hora de separar um módulo em serviço, fazem isso com um motivo claro. Não fazem isso só porque todo mundo está fazendo o mesmo.
*Este conteúdo foi elaborado com IA, tendo como base a transcrição do episódio do Entre Chaves, e passou por curadoria e revisão humana. Para ouvir a conversa completa, acesse o episódio.

