Imagine a cena. Três equipes trabalham no mesmo repositório de frontend. Uma equipe quer atualizar o React. Outra está no meio de uma funcionalidade crítica. A terceira acabou de encontrar um bug em produção. Qualquer alteração de uma delas pode quebrar o trabalho das outras duas.
Os deploys viram eventos de coordenação: uma reunião antes, uma reunião depois, sempre alguém esperando outra pessoa terminar. O sistema funciona, mas ninguém consegue avançar rápido.
Esse é o problema que os microfrontends tentam resolver. A solução só faz sentido se você já sentiu essa dor na prática.
O que são microfrontends, sem jargão técnico#
Você provavelmente já ouviu falar de microsserviços no backend: em vez de uma API monolítica, você tem serviços menores e independentes, cada um com sua própria responsabilidade, seu próprio deploy e sua própria equipe.
Os microfrontends aplicam a mesma lógica ao frontend. A interface é dividida em partes menores e cada parte é desenvolvida, testada e publicada de forma independente.
Uma metáfora ajuda. Pense em uma cidade. O metrô não depende da coleta de lixo para funcionar, e o hospital não espera a prefeitura reformar a biblioteca para atender os pacientes. Cada serviço opera por conta própria, mas todos compartilham a mesma cidade e atendem os mesmos moradores.
Sua aplicação é a cidade. Cada microfrontend é um serviço urbano.
O monolito não é o vilão, ele apenas tem limites#
"Monolito" não é palavrão. Se a sua equipe é pequena, a aplicação tem porte médio e os deploys acontecem sem atrito, o monolito é a escolha certa: menos complexidade, menos infraestrutura e menos coordenação.
Um monolito sofrendo:
- 3 ou mais equipes no mesmo repositório
- Deploys causam conflitos entre equipes
- Atualizar uma biblioteca quebra outra parte da aplicação
- O code review virou um gargalo
- Reescrever qualquer parte parece arriscado demais
Um monolito saudável:
- Equipe pequena, base de código gerenciável
- Deploys simples e previsíveis
- Contexto claro para toda a equipe
- Sem sobrecarga de coordenação
- Rápido para iterar
Microfrontends resolvem problemas de escala — tanto escala de equipe quanto de produto. Se você ainda não tem esses problemas, a arquitetura vai gerar mais complexidade do que eliminar.
Como funciona na prática#
Toda arquitetura de microfrontends tem uma peça central: o Shell (ou Host), a aplicação que reúne e monta as partes. Ele funciona como a moldura de um quebra-cabeça: não contém nenhuma parte da imagem, apenas define onde cada peça se encaixa.
Shell (Host) — carrega, compõe e roteia
├── MFE: Catálogo (Equipe A · React 18)
├── MFE: Checkout (Equipe B · Vue 3)
└── MFE: Perfil (Equipe C · React 19)Cada microfrontend pode usar uma stack diferente. A equipe A está no React 18, a equipe B escolheu Vue e a equipe C já migrou para o React 19. Todos convivem na mesma aplicação final, e os usuários nunca percebem que são sistemas separados.
A tecnologia mais comum para isso é o Module Federation, um recurso do Webpack 5 que permite que aplicações compartilhem módulos em tempo de execução sem empacotá-los juntos.
// webpack.config.js para o MFE de Catálogo
new ModuleFederationPlugin({
name: "catalog",
filename: "remoteEntry.js",
exposes: {
"./Catalog": "./src/Catalog",
},
shared: ["react", "react-dom"],
});
// webpack.config.js para o Shell, consumindo o MFE
new ModuleFederationPlugin({
name: "shell",
remotes: {
catalog: "catalog@http://localhost:3001/remoteEntry.js",
},
shared: ["react", "react-dom"],
});O que é o remoteEntry.js? É o ponto de entrada do microfrontend: um arquivo que o Shell lê em tempo de execução para descobrir quais módulos estão disponíveis. Cada MFE publica o seu, e o Shell só precisa conhecer o endereço.
O que cada equipe realmente ganha#
Artigos sobre microfrontends falam muito sobre autonomia, mas sozinha a palavra é abstrata. O que muda no dia a dia?
Deploys independentes#
A equipe de Checkout encontra um bug crítico no fluxo de pagamento. Eles corrigem, testam e publicam sem precisar avisar a equipe de Catálogo e sem esperar a equipe de Perfil terminar a funcionalidade em que está trabalhando. O restante da aplicação continua exatamente como estava.
Tecnologia adequada ao contexto#
Diferentes partes de um sistema têm necessidades distintas. Um painel administrativo cheio de tabelas e filtros pode se beneficiar de uma biblioteca especializada em grids de dados, enquanto a área de marketing pode preferir um framework mais leve. Cada equipe escolhe a ferramenta certa para o seu problema, e essa escolha não se espalha pelo sistema inteiro.
Migração incremental#
Um monolito legado em Angular 8 em que ninguém quer mexer pode ser encapsulado aos poucos em vez de reescrito do zero — o que levaria meses e congelaria o produto. Novas funcionalidades são entregues como microfrontends modernos, e o código legado vai encolhendo sem parar o negócio.
Netflix, Spotify e IKEA usam variações de microfrontends para resolver exatamente isso: equipes grandes, produtos complexos e a necessidade de avançar rápido sem quebrar o que já funciona.
Os custos reais#
Microfrontends têm um preço, e ignorá-lo sai caro.
Complexidade de infraestrutura#
Você sai de um repositório e um deploy para múltiplos repositórios, pipelines e URLs de produção. Cada microfrontend precisa do seu próprio CI/CD, e o Shell precisa saber onde cada MFE roda em cada ambiente. Isso exige um nível de maturidade em DevOps que muitas equipes ainda não têm.
Consistência visual#
Se cada equipe é autônoma, quem garante que os botões sigam o mesmo estilo, os espaçamentos sejam consistentes e a tipografia combine? A resposta é um Design System compartilhado, e manter um bom Design System já é um trabalho por si só.
Cuidado com o efeito Frankenstein. Autonomia sem padrões vira caos visual. Os usuários não sabem que existem equipes diferentes por trás da tela; eles apenas enxergam uma aplicação inconsistente.
Performance#
Se o Shell carrega três microfrontends e cada um embarca o React no próprio bundle, o React é executado três vezes. A opção shared do Module Federation resolve isso, mas exige configuração cuidadosa. Sem esse cuidado, o tamanho do payload cresce rápido.
Comunicação entre MFEs#
Em algum momento, um microfrontend vai precisar conversar com outro. Quando um usuário faz login pelo MFE de Perfil, o MFE de Catálogo precisa saber para exibir seus favoritos. Mantenha essa comunicação no mínimo possível. O mecanismo mais seguro são eventos nativos do navegador, sem dependências diretas entre MFEs.
// O MFE de Perfil dispara um evento após o login
window.dispatchEvent(new CustomEvent("user:loggedIn", {
detail: { userId: "42", name: "Ana" }
}));
// O MFE de Catálogo escuta sem acoplamento direto
window.addEventListener("user:loggedIn", (e) => {
loadFavorites(e.detail.userId);
});Quando faz sentido e quando não faz#
A pergunta que importa é se o seu contexto justifica essa complexidade.
Faz sentido quando:
- Múltiplas equipes trabalham em paralelo na mesma aplicação
- O monolito está travando deploys e exigindo coordenação excessiva
- Partes do sistema têm ciclos de vida ou requisitos técnicos muito diferentes
- Você precisa migrar um sistema legado sem parar o produto
Não faz sentido quando:
- Você tem uma equipe pequena e alinhada
- A aplicação é de porte médio e fácil de manter
- Você ainda está descobrindo o produto e muda de direção com frequência
- Ninguém na equipe tem experiência com sistemas distribuídos
O que levar desta leitura#
- Microfrontends aplicam a lógica dos microsserviços ao frontend.
- O Shell compõe e roteia; os MFEs são autônomos e independentes.
- Module Federation é a tecnologia mais comum para composição em tempo de execução.
- Deploys independentes são o benefício mais concreto: equipes avançam sem travar umas às outras.
- O custo envolve mais infraestrutura, um Design System e atenção à performance.
- Antes de adotar, pergunte se o seu problema justifica a complexidade. Se não justificar, o monolito resolve bem.
