- PostgreSQL resolve 80% dos casos — é relacional, robusto, open-source e cresce sem reescrever
- MongoDB brilha para documentos com estrutura variável e escrita intensiva (IoT, logs, catálogos)
- MySQL ainda domina em hospedagem compartilhada e stacks LAMP legadas — menos features que PostgreSQL
- A escolha mais importante: não é qual banco, é garantir que os dados têm integridade desde o início
- Usar múltiplos bancos é uma estratégia válida — PostgreSQL + Redis + S3 é combinação clássica
- Custo de migração entre bancos é 5-20× maior que o custo de escolher certo no início
A premissa errada que leva à escolha errada
A pergunta "qual banco é melhor?" está errada. A pergunta correta é "qual banco é melhor para este modelo de dados, este volume e esta equipe?"
Cada banco foi otimizado para cenários específicos. Usar MongoDB como se fosse relacional (com joins manuais na aplicação) é doloroso. Usar PostgreSQL para dados hierárquicos altamente variáveis é possível, mas trabalhoso.
Os três erros mais comuns na escolha:
- Escolher por hype: "MongoDB é NoSQL, NoSQL é moderno, vou usar MongoDB". NoSQL não é sinônimo de moderno — é uma ferramenta para problemas específicos.
- Escolher pelo que a big tech usa: Facebook usa Cassandra para dados de 3 bilhões de usuários. Você tem 3.000 usuários. O contexto é completamente diferente.
- Não escolher (usar qualquer um): "Banco é banco, tanto faz". Essa decisão vai custar 6 meses de migração dolorosa quando bater em algum limite.
Este guia te dá os critérios para fazer a escolha certa — com dados, não opinião.
PostgreSQL resolve 80% dos problemas de banco de dados. Se você chegou até aqui e ainda não tem certeza, use PostgreSQL. Você pode adicionar outros bancos depois, quando a necessidade for real — não hipotética.
PostgreSQL: o banco de dados padrão do mundo moderno
PostgreSQL é o banco relacional open-source mais avançado disponível. Em 2026, acumula funcionalidades que antes existiam apenas em bancos enterprise caros (Oracle, SQL Server) — sem custo de licença.
Core features que definem PostgreSQL
- ACID completo: Transações robustas com isolation levels configuráveis (Read Committed até Serializable). Sem perda de dados, sem inconsistências.
- JSON nativo (jsonb): Coluna jsonb com indexação GIN permite armazenar e consultar dados semiestruturados com performance excelente. Em muitos casos, elimina a necessidade de MongoDB.
- Full-text search: Busca textual com ranking nativo (ts_vector, ts_query). Para volumes até ~5M de documentos, elimina Elasticsearch.
- pgvector: Busca vetorial (embeddings de IA) direto no banco — até ~5M vetores com performance aceitável. Sem precisar de Pinecone ou Weaviate.
- Row-level security (RLS): Políticas de acesso a nível de linha, nativas. Ideal para multi-tenancy: cada tenant vê apenas seus dados sem lógica extra na aplicação.
- Extensões poderosas: PostGIS (geoespacial, padrão da indústria), TimescaleDB (séries temporais), pgcrypto (criptografia), pg_stat_statements (análise de queries).
- Particionamento nativo: Tabelas com bilhões de registros divididas automaticamente por data, região ou qualquer critério.
- Logical replication: Réplicas de leitura sem downtime, CDC (Change Data Capture) para streaming de eventos.
Performance do PostgreSQL em 2026
| Cenário | Volume | Performance |
|---|---|---|
| Leituras simples (SELECT por PK) | 10M registros | <1ms por query |
| JOINs complexos (3-4 tabelas) | 10M registros | 5-50ms com índices |
| Full-text search | 5M documentos | 10-100ms |
| Busca vetorial (pgvector) | 1M vetores 1536-dim | 20-100ms |
| Escrita transacional | Pico | ~10-30k writes/seg (single node) |
| JSON queries (jsonb) | 1M docs | 5-30ms com GIN index |
Quando PostgreSQL NÃO é suficiente
- Escrita com throughput absurdo: >100k writes/seg sem batch — considere Cassandra, ScyllaDB ou TimescaleDB.
- Clustering horizontal automático: PostgreSQL escala verticalmente muito bem e horizontalmente com read replicas, mas não tem sharding automático nativo como MongoDB ou CockroachDB.
- Dados efêmeros de altíssimo volume: Logs de acesso com 100M+ registros/dia — considere ClickHouse ou banco de séries temporais.
Facebook usa Cassandra, Netflix usa DynamoDB, Airbnb usa MySQL. Eles têm volumes, equipes e contextos que você não tem. Escolha pelo seu contexto — não pelo case study de outro.
MongoDB: o banco certo para o modelo de documento
MongoDB é frequentemente mal utilizado — ora como substituto do relacional (péssima ideia), ora como "banco para startups" sem critério técnico. Quando usado para o que foi projetado, é excelente.
Core features que definem MongoDB
- Schema flexível: Cada documento pode ter estrutura diferente na mesma collection. Ideal para catálogos onde cada produto tem atributos únicos.
- Sharding automático: Distribuição horizontal de dados entre nós. Configuração simples comparada ao PostgreSQL Citus.
- Atlas (gerenciado): Experiência de developer experience excelente — deploy em 3 cliques com monitoramento, backup e alertas incluídos.
- Aggregation Pipeline: Framework de processamento de dados potente, similar a SQL com GROUP BY/HAVING mas mais expressivo para dados hierárquicos.
- Change Streams: Reatividade nativa — aplicações podem escutar mudanças em tempo real (similar a CDC do PostgreSQL).
- Atlas Search: Full-text search integrado (baseado em Apache Lucene), eliminando necessidade de Elasticsearch em ecossistema MongoDB.
Quando MongoDB brilha
| Caso de uso | Por que MongoDB | Exemplo real |
|---|---|---|
| Catálogo com atributos variáveis | Cada doc tem schema próprio | E-commerce com eletrônicos (specs técnicas) e roupas (tamanhos, cores) |
| IoT / dados de sensores | Escrita intensiva, leitura eventual | 100k sensores enviando 1 leitura/seg = 8.6B docs/dia |
| Logs de aplicação | Volume alto, schema variável por tipo | Logs de API, eventos de UX, erros com stack trace |
| Content Management | Documentos com estrutura hierárquica | Blog com tipos de conteúdo diferentes (artigo, vídeo, podcast) |
| Gaming / leaderboards | Leituras rápidas, schema flexível | Perfis de jogadores com inventários de itens variáveis |
Quando MongoDB é a escolha errada
- Dados fortemente relacionados: Pedidos com itens, pagamentos, clientes, endereços — tudo interligado. JOINs no MongoDB ($lookup) são lentos e verbosos. Use relacional.
- Transações multi-documento frequentes: MongoDB tem transações multi-documento desde v4.0, mas são significativamente mais lentas que em bancos relacionais. Se >30% das operações são transacionais, relacional é melhor.
- Relatórios e analytics: Aggregation Pipeline é potente mas a sintaxe é complexa. SQL é mais legível para queries analíticas e possui ecossistema BI muito mais maduro.
- "Banco para startups": A ausência de schema validation não elimina a necessidade de modelagem. Apenas transfere a validação do banco para a aplicação — onde é mais frágil.
Independente do banco escolhido: defina constraints (NOT NULL, UNIQUE, FOREIGN KEY) desde o primeiro schema. Dados sem integridade são o maior gerador de bugs silenciosos em sistemas legados.
MySQL: legado dominante que ainda tem seu lugar
MySQL ainda é o banco mais instalado do mundo — herdado de décadas de stacks LAMP (Linux, Apache, MySQL, PHP). Em 2026, perdeu terreno significativo para PostgreSQL em novos projetos, mas mantém relevância em cenários específicos.
O que MySQL faz bem
- Hospedagem compartilhada: Praticamente todos os planos de hosting (cPanel, Plesk) incluem MySQL. PostgreSQL é mais raro nesses ambientes.
- Stacks WordPress/Drupal/PHP: Mudar de MySQL é risco sem benefício claro quando a aplicação é um CMS estável.
- Read-heavy workloads com InnoDB: Performance excelente em leituras simples com o storage engine InnoDB.
- Replicação master-slave madura: Configuração simples e estável para read replicas.
- Familiaridade da equipe: Se a equipe tem 10 anos de MySQL e o projeto dura 6 meses, mudar de banco não compensa.
Por que NÃO escolher MySQL para projetos novos
| Feature | PostgreSQL | MySQL 8.x |
|---|---|---|
| JSON nativo (indexado) | jsonb com GIN — busca rápida | JSON com geração virtual — mais lento |
| Full-text search | ts_vector/ts_query com ranking | FULLTEXT básico (InnoDB), sem ranking sofisticado |
| Window functions | Completas desde PostgreSQL 8.4 (2009) | Adicionadas no MySQL 8.0 (2018) — menos maduras |
| CTEs recursivas | Maduras e otimizadas | Adicionadas no 8.0 — menos otimizadas |
| Busca vetorial | pgvector — maduro | Não nativo (precisa de plugin externo) |
| Geoespacial | PostGIS — padrão da indústria | Spatial Extensions — funcional mas limitado |
| Particionamento | Declarativo nativo | Range/List/Hash — menos flexível |
| Row-level security | Nativo (RLS policies) | Não nativo — requer views ou lógica na app |
| Conformidade SQL | Alta (segue SQL standard) | Média (permissividades como GROUP BY sem ALL) |
Resumo: PostgreSQL tem tudo que MySQL tem, mais funcionalidades enterprise, melhor conformidade SQL, e ecossistema de extensões mais rico. Para projetos novos sem restrição de hosting, PostgreSQL é a escolha superior.
Migrar de MongoDB para PostgreSQL custa 3-6 meses de engenharia. Migrar de MySQL para PostgreSQL custa 2-4 semanas. Tempo investido na decisão inicial se paga exponencialmente.
Comparativo completo: 12 critérios técnicos lado a lado
| Critério | PostgreSQL | MongoDB | MySQL |
|---|---|---|---|
| Modelo de dados | Relacional + JSON (jsonb) | Documento (BSON) | Relacional |
| ACID | Completo (desde sempre) | Multi-documento (desde v4.0) | Completo (InnoDB) |
| Schema | Rígido (DDL) + flexível (jsonb) | Flexível (opcional) | Rígido (DDL) |
| Escala horizontal | Read replicas + Citus (sharding) | Sharding nativo — setup simples | Read replicas + Vitess |
| Escrita intensiva | 10-30k/seg (single node) | 50-100k/seg (single node, durabilidade padrão) | 10-25k/seg (InnoDB) |
| JOINs | Nativos (INNER, LEFT, LATERAL) | $lookup (lento, limitado) | Nativos |
| Full-text search | ts_vector (bom até 5M docs) | Atlas Search (Lucene-based) | FULLTEXT (básico) |
| Busca vetorial | pgvector (até ~5M vetores) | Atlas Vector Search | Não nativo |
| Ecossistema BI | Excelente (Metabase, Grafana, dbt) | Limitado (MongoDB Connector) | Bom (ferramentas SQL padrão) |
| Gerenciado (cloud) | Supabase, Neon, RDS, Cloud SQL | Atlas (excelente DX) | RDS, PlanetScale, Cloud SQL |
| Licença | PostgreSQL License (liberal) | SSPL (restritiva para SaaS) | GPL v2 (Oracle) |
| Curva de aprendizado | SQL — alta empregabilidade | MQL — menor base de devs | SQL — familiar |
Leitura do comparativo
- Se precisa de JOINs e transações: PostgreSQL > MySQL > MongoDB.
- Se precisa de escrita massiva: MongoDB > PostgreSQL > MySQL.
- Se precisa de schema flexível: MongoDB > PostgreSQL (jsonb) > MySQL.
- Se precisa de ecossistema BI: PostgreSQL > MySQL > MongoDB.
- Se precisa escalar horizontalmente: MongoDB > PostgreSQL (com Citus) > MySQL (com Vitess).
- Se precisa de busca vetorial/IA: PostgreSQL (pgvector) ≈ MongoDB (Atlas Vector) > MySQL.
Árvore de decisão: fluxograma prático para escolher
Use este fluxograma para chegar à resposta em 3 perguntas:
Pergunta 1: Os dados são fortemente relacionados?
Sim (pedidos → itens → pagamentos → clientes → endereços): banco relacional (PostgreSQL ou MySQL). Siga para a pergunta 2.
Não (cada documento é independente, poucos relacionamentos, estrutura variável): considere MongoDB. Siga para a pergunta 3.
Pergunta 2 (relacional): Tem restrição de hosting ou stack LAMP?
Sim (hosting compartilhado, WordPress, equipe só sabe MySQL): MySQL.
Não: PostgreSQL. Sem exceção.
Pergunta 3 (documento): >30% das operações são transacionais?
Sim: Reconsidere. PostgreSQL com jsonb pode ser melhor que MongoDB com transações pesadas.
Não: MongoDB. Ideal para dados de documento com escrita intensiva e schema variável.
Cenário por tipo de projeto
| Tipo de projeto | Banco primário | Complementos |
|---|---|---|
| SaaS B2B (ERP, CRM) | PostgreSQL | Redis (cache), S3 (arquivos) |
| E-commerce | PostgreSQL | Redis (sessões), Elasticsearch (busca de produtos) |
| App mobile com chat | PostgreSQL | Redis (pub/sub), S3 (mídia) |
| IoT / telemetria | TimescaleDB ou MongoDB | PostgreSQL (dados de negócio), Redis (alertas) |
| CMS / blog corporativo | PostgreSQL ou MongoDB | CDN (assets), Redis (cache de páginas) |
| Fintech / pagamentos | PostgreSQL (ACID obrigatório) | Redis (rate limiting), S3 (comprovantes) |
| IA / RAG sobre documentos | PostgreSQL + pgvector | S3 (documentos originais), Redis (cache de queries) |
| WordPress / Drupal | MySQL | Redis (cache), CDN (assets) |
Custos operacionais: comparativo por perfil de empresa
Custo mensal por volume (serviço gerenciado em cloud)
| Perfil | PostgreSQL (Supabase/Neon) | MongoDB Atlas | MySQL (PlanetScale/RDS) |
|---|---|---|---|
| Hobby (1 dev, <1GB) | R$ 0 (free tier) | R$ 0 (free tier 512MB) | R$ 0 (free tier) |
| Startup (5GB, 5k queries/seg) | R$ 100-300 | R$ 150-400 (M10) | R$ 100-250 |
| PME (50GB, 20k queries/seg) | R$ 400-800 | R$ 600-1.500 (M30) | R$ 400-800 |
| Enterprise (500GB+, 100k queries/seg) | R$ 2.000-5.000 | R$ 3.000-10.000 (M50+) | R$ 2.000-5.000 |
Custos ocultos
- MongoDB Atlas egress: Transferência de dados para fora do Atlas é cobrada (~R$ 0,50/GB acima do free tier). Se sua API faz muitas queries, o egress pode superar o custo do cluster.
- MongoDB licença SSPL: Se você vende banco como serviço (DBaaS), a licença SSPL do MongoDB pode ser um problema legal. PostgreSQL e MySQL não têm essa restrição.
- Expertise da equipe: MongoDB exige conhecimento de modelagem de documentos — que é fundamentalmente diferente de modelagem relacional. Equipe relacional usando MongoDB gera modelagem pobre (e problemas de performance).
- Custo de migração futura: Migrar de MongoDB para PostgreSQL custa 3-6 meses de engenharia. Migrar de MySQL para PostgreSQL custa 2-4 semanas (schemas similares). Escolher errado tem custo real.
Self-hosted vs. gerenciado
Recomendação: Use gerenciado para times com <3 engenheiros de infra. O custo adicional de ~30% do serviço gerenciado é muito menor que o custo de um DBA administrando backup, replicação, failover, monitoring e updates de segurança.
Self-hosted faz sentido quando: compliance exige dados on-premises, volume é tão alto que o custo gerenciado fica proibitivo (>R$ 10k/mês), ou quando há equipe de infra dedicada.
Migração entre bancos: quando, como e quanto custa
Quando migrar
- MySQL → PostgreSQL: Quando precisa de jsonb, pgvector, PostGIS, RLS, ou conformidade SQL avançada. Migração relativamente simples (schemas similares). Custo: 2-4 semanas de engenharia.
- MongoDB → PostgreSQL: Quando o modelo de dados se tornou fortemente relacional (muitos $lookups) e transações são frequentes. Migração complexa (redesign do schema). Custo: 3-6 meses de engenharia.
- PostgreSQL → MongoDB: Raro. Se o modelo de dados se tornou predominantemente documental e escrita é o gargalo. Avalie antes pgvector + jsonb.
Estratégia de migração: Strangler Fig
- Dual write: Novas operações escrevem nos dois bancos simultaneamente
- Migração de dados históricos: ETL para transferir dados existentes em lotes
- Validação: Compare resultados de queries nos dois bancos durante 2-4 semanas
- Cutover: Mude a leitura para o novo banco
- Cleanup: Remova o dual write e descomissione o banco antigo
Ferramentas de migração
| Migração | Ferramenta | Observação |
|---|---|---|
| MySQL → PostgreSQL | pgloader | Automatiza 90% da conversão de schema e dados |
| MongoDB → PostgreSQL | Custom ETL (Python/Node) | Cada collection vira 1+ tabelas — modelagem manual |
| MySQL → MongoDB | mongomigrate / custom | Desnormalização manual necessária |
| Qualquer → Qualquer | Airbyte / Fivetran | ETL gerenciado, bom para migração contínua |
Arquitetura multi-banco: usando o certo para cada tipo de dado
Sistemas modernos não usam um único banco para tudo. A combinação certa reduz custos, melhora performance e simplifica cada componente.
Combinação clássica (cobre 90% dos projetos)
| Banco | Função | Exemplos de dados |
|---|---|---|
| PostgreSQL | Dados transacionais (SSOT) | Pedidos, clientes, pagamentos, contratos, usuários |
| Redis | Cache, sessões, filas | Sessões de login, cache de API, rate limiting, pub/sub |
| S3/GCS | Object storage | Uploads, backups, PDFs, imagens, vídeos |
Combinação avançada (projetos com IA ou analytics)
| Banco | Função |
|---|---|
| PostgreSQL + pgvector | Dados transacionais + busca vetorial (RAG, recomendação) |
| ClickHouse | Analytics de alto volume (eventos, métricas, logs de negócio) |
| Redis | Cache, sessões, feature flags |
| S3 | Data lake (documentos brutos para processamento batch) |
Anti-padrões de multi-banco
- PostgreSQL como cache: Fazer SELECT frequente em tabela sem índice para "verificar" dados que poderiam estar no Redis. Banco relacional não é cache.
- MongoDB como fila: Collections com "status: pendente" para processar tarefas. Use Redis, SQS ou RabbitMQ.
- Duplicação desnecessária: Manter os mesmos dados no PostgreSQL e no MongoDB "por segurança". Escolha um como SSOT e replique com propósito (analytics, busca).
- Micro-bancos por microserviço: Cada microserviço com seu banco é a teoria. Na prática, para equipes com <10 devs, um banco PostgreSQL com schemas separados é mais simples e igualmente eficaz.
Conclusão: a regra dos 80/20 para bancos de dados
Se você leu este guia inteiro e ainda não tem certeza: use PostgreSQL. Ele resolve 80% dos problemas de banco de dados, tem o ecossistema mais completo de extensões, a maior comunidade e a melhor empregabilidade para quem aprende SQL.
Resumo em 5 regras
- Novo projeto sem restrições? PostgreSQL.
- Dados hierárquicos, variáveis, escrita intensiva? MongoDB.
- Stack PHP/WordPress em hosting compartilhado? MySQL.
- Precisa de cache, sessões ou filas? Adicione Redis — não abuse do banco principal.
- Precisa de busca vetorial para IA? pgvector (se PostgreSQL) ou Atlas Vector Search (se MongoDB).
O banco de dados é a fundação do sistema. Errar aqui gera meses de migração dolorosa. Acertar aqui gera anos de produtividade. Invista 1-2 dias na decisão — vale mais do que semanas de refatoração depois.
Mapa Mental
Use ← → para navegar · Espaço para expandir