Neste artigo você vai entender, com clareza e sem enrolação, os conceitos de arquitetura mais usados como monolito, microserviços e serverless — além de saber quando escolher cada arquitetura.
1. Monolito
O que é?
Um monolito é uma aplicação única e centralizada. Todo o código (backend, lógica de negócio, acesso a banco, etc.) vive no mesmo projeto e é executado como um único processo.
Características:
- Um único deploy.
- Fácil de começar, difícil de escalar.
- Tudo está acoplado no mesmo código.
Quando usar?
- Projetos pequenos ou MVPs.
- Quando a equipe é reduzida.
- Quando há pouco domínio técnico distribuído.
// Exemplo de estrutura monolito:
src/
controllers/
userController.ts
services/
userService.ts
repositories/
userRepository.ts
index.ts (Express server que junta tudo)
Vantagens:
- Rápido para desenvolver.
- Menor complexidade inicial.
- Simples para fazer deploy.
Desvantagens:
- Dificulta a escalabilidade em times grandes.
- Uma mudança pode quebrar tudo.
- Deploys são pesados e arriscados.
2. Microserviços
O que é?
Microserviços são uma abordagem onde a aplicação é dividida em vários serviços pequenos e independentes, cada um com uma responsabilidade clara.
Características:
- Cada serviço é deployado separadamente.
- Comunicação via HTTP, gRPC, filas, etc.
- Mais trabalho inicial, mas escalável a longo prazo.
Quando usar?
- Equipes grandes e especializadas.
- Projetos com múltiplos domínios e integrações.
- Necessidade de escalar partes diferentes do sistema separadamente.
// Exemplo:
services/
auth-service/
src/index.ts
user-service/
src/index.ts
payment-service/
src/index.ts
// Cada serviço com seu próprio Dockerfile, banco e CI/CD
Vantagens:
- Isolamento de responsabilidade.
- Times independentes podem trabalhar sem bloqueio.
- Escala técnica e organizacional.
Desvantagens:
- Complexidade de orquestração.
- Necessita infraestrutura e monitoramento.
- Mais difícil de testar integração.
3. Serverless
O que é?
Serverless é uma arquitetura onde você escreve apenas funções isoladas que são executadas sob demanda, sem se preocupar com servidores.
Características:
- Custo baseado no uso (pay-per-request).
- Escala automática.
- Ideal para workloads intermitentes.
Quando usar?
- Aplicativos de baixa/média carga.
- Integrações event-driven (pagamentos, e-mails, webhooks, blogs).
- Quando o time quer focar só na lógica.
// Exemplo:
// handler.ts
export const handler = async (event) => {
const { name } = JSON.parse(event.body);
return {
statusCode: 200,
body: JSON.stringify({ message: `Hello, ${name}` })
};
}
// Deploy em plataformas como AWS Lambda, Vercel, Netlify, etc.
};
Vantagens:
- Não precisa gerenciar servidores.
- Alto desempenho com baixo custo.
- Escalabilidade automática.
Desvantagens:
- Frio (cold start) pode ser problema.
- Difícil manter controle de execução e logs.
- Limitações de tempo e recursos por função.
🤔 Qual escolher?
| Critério | Monolito | Microserviços | Serverless | | ------------------ | ---------- | --------------- | -------------------- | | Facilidade inicial | ✅ Alta | ❌ Mais complexa | ✅ Alta | | Escalabilidade | ❌ Limitada | ✅ Alta | ✅ Automática | | Custo de operação | ✅ Baixo | ❌ Alto | ✅ Sob demanda | | Time pequeno | ✅ Ideal | ❌ Difícil | ✅ Ideal | | Time grande | ❌ Limitado | ✅ Ideal | ✅ Dependente do caso |
🌟 Conclusão
- Use monolito para começar rápido.
- Evolua para microserviços se o domínio crescer e o time precisar de escalabilidade.
- Aposte em serverless para workloads específicos e com eventos.
Não existe bala de prata. O importante é escolher com consciência. Se você entende os prós e contras, você está no controle.