Quando usar MongoDB (e quando PostgreSQL é melhor)
Use MongoDB quando a entidade é lida e gravada como um bloco e o schema varia. Prefira PostgreSQL para relações N:N, relatórios e transações.
Você abriu o MongoDB porque alguém no time disse que "schema rígido atrasa o produto", modelou tudo como documento aninhado e, três meses depois, está escrevendo $lookup em cima de $lookup para juntar pedidos, clientes e pagamentos. A sensação é familiar: você reinventou o JOIN, só que com menos ajuda do banco, e as transações entre coleções, que existem, ficaram mais caras e mais limitadas do que você imaginava. O problema raramente é o MongoDB. É ter escolhido o modelo de documentos para um dado que, no fundo, é relacional.
A resposta curta: use MongoDB quando a entidade tem uma fronteira clara (é lida e gravada como um bloco, por uma chave) e o formato varia entre registros. Prefira PostgreSQL quando o dado é uma rede de relações consultada de vários ângulos, quando há relatórios cruzados e quando a regra de negócio depende de transações entre várias entidades. O resto deste post detalha esses critérios, com exemplos que eu rodei no MongoDB 8.0 e no PostgreSQL 17.
O que é, de fato, um documento
No modelo relacional você quebra uma entidade em várias tabelas normalizadas e remonta com JOINs na hora da leitura. No MongoDB você guarda a entidade do jeito que ela é consumida: um pedido com seus itens e um snapshot do cliente, tudo num único documento BSON.
{
"_id": "ord_8821",
"cliente": { "id": "cli_42", "nome": "Ana Lima" },
"itens": [
{ "sku": "TEC-01", "qtd": 2, "preco": 149.9 },
{ "sku": "MOU-03", "qtd": 1, "preco": 89.0 }
],
"total": 388.8,
"status": "pago"
}
A regra que a própria documentação do MongoDB repete é: dados acessados juntos ficam guardados juntos. Se a sua tela mostra o pedido inteiro de uma vez, ler esse documento é uma única consulta por _id, sem JOIN. É aí que o modelo de documentos brilha, e é aí que a maioria das pessoas erra ao avaliar a tecnologia: julga o banco pelo caso em que o dado não tem esse formato.
MongoDB vs PostgreSQL em 5 critérios
| Critério | MongoDB | PostgreSQL |
|---|---|---|
| Forma do dado | Agregado autocontido, lido por chave | Entidades independentes ligadas por relações |
| JOINs | $lookup no pipeline de agregação; funciona, mas o modelo pede para evitar |
JOIN é o caso de uso central, com otimizador maduro |
| Transações | Multi-documento desde 4.0 (replica set) e 4.2 (sharded); limite padrão de 60 s | ACID entre quaisquer tabelas, sem limite de duração por padrão |
| Schema | Flexível por padrão; validação opcional com $jsonSchema |
Rígido por padrão; flexível onde você quiser com JSONB |
| Escala horizontal | Sharding nativo por chave | Réplicas de leitura nativas; sharding de escrita depende de extensão ou arquitetura |
A última linha da tabela é a que mais pesa na conversa e a que menos importa para a maioria dos projetos: um único servidor PostgreSQL bem configurado aguenta muito mais do que a maioria dos produtos vai precisar. Se a decisão for entre PostgreSQL e outro relacional, o comparativo de PostgreSQL vs MySQL cobre a outra metade da escolha.
Quando usar MongoDB
Documentos vencem quando o formato do dado e o padrão de acesso estão a favor:
- A entidade é lida e escrita como um bloco. Carrinho, perfil de usuário, configuração de conta, post com comentários embutidos. Você quase nunca quer "só os itens" sem o pedido.
- O schema varia entre registros. Catálogo de produtos em que uma TV tem polegadas e uma camiseta tem tamanho. No relacional isso vira coluna nula ou tabela de atributos genérica (o famigerado EAV); no documento, cada produto carrega só os campos que tem.
- O dado evolui rápido e vários formatos convivem. O ganho aqui não é fugir do custo do
ALTER TABLE(já falo disso), e sim poder ter documentos antigos e novos lado a lado sem uma migração coordenada a cada mudança. - Você precisa escalar escrita horizontalmente. O sharding nativo distribui documentos por chave entre shards. É um caminho mais direto do que particionar um relacional na mão.
- O dado já chega semiestruturado. Eventos, payloads de webhook, telemetria: coisas de alto volume que entram em formatos irregulares.
Repare no padrão: todos esses casos têm uma fronteira de agregação clara. O documento é a unidade natural de leitura e de escrita.
"Schema flexível" não quer dizer "sem schema"
Desde a versão 3.6, o MongoDB valida documentos com $jsonSchema no momento da escrita. Flexível é o padrão, não a única opção:
db.createCollection("pedidos", {
validator: {
$jsonSchema: {
bsonType: "object",
required: ["cliente", "itens", "total", "status"],
properties: {
itens: { bsonType: "array", minItems: 1 },
total: { bsonType: ["double", "int", "decimal"], minimum: 0 },
status: { enum: ["aberto", "pago", "cancelado"] }
}
}
}
})
db.pedidos.insertOne({ cliente: { id: "cli_42" }, itens: [], total: 0, status: "pago" })
// MongoServerError: Document failed validation
Rodei no MongoDB 8.0: o pedido sem itens é recusado. Se o argumento para escolher MongoDB é "não queremos schema", vale saber que em algum momento você vai querer, e que dá para ter.
Quando não usar MongoDB (e PostgreSQL é melhor)
Aqui mora o erro de origem. O modelo de documentos cobra caro quando o dado é, na essência, uma rede de relações muitos-para-muitos consultada de ângulos diferentes:
- Muitos JOINs entre entidades independentes. Se quase toda query precisa de
$lookupligando coleções distintas, o dado é relacional. O$lookupfunciona, mas você está usando o banco no terreno onde ele é menos natural. - Transações entre várias entidades são o centro da regra. O MongoDB tem transações ACID multi-documento desde a 4.0 em replica sets e desde a 4.2 em clusters shardados. Elas funcionam: rodei a transferência entre duas contas abaixo num replica set de um nó e o commit foi atômico. Mas a documentação é explícita que uma transação distribuída custa mais que escritas em um único documento e que ela não substitui um bom desenho de schema. E há limites: por padrão a transação precisa terminar em menos de um minuto (
transactionLifetimeLimitSeconds = 60), e emmongodstandalone ela nem está disponível. - A mesma informação é consultada por vários eixos. Um relatório que cruza vendas por região, por vendedor e por produto se beneficia de tabelas normalizadas e SQL. Duplicar isso em documentos vira pesadelo de consistência.
- Auditoria e relatórios assumem SQL. Ferramentas de BI, conciliação e auditoria costumam falar SQL de primeira. Não é exigência regulatória escolher um tipo de banco, mas é atrito real quando o dado financeiro mora num banco de documentos.
const s = db.getMongo().startSession()
const contas = s.getDatabase("loja").contas
s.startTransaction()
try {
contas.updateOne({ _id: "A", saldo: { $gte: 300 } }, { $inc: { saldo: -300 } })
contas.updateOne({ _id: "B" }, { $inc: { saldo: 300 } })
s.commitTransaction()
} catch (e) {
s.abortTransaction()
throw e
}
Existe ainda o custo silencioso: para evitar JOINs você duplica dados (o snapshot do cliente em cada pedido, por exemplo). Isso consome mais disco e cria o problema de manter cópias sincronizadas quando o original muda. Se você se pegou escrevendo rotinas para propagar a troca de nome de um cliente por 40 mil documentos, o modelo está errado para esse dado. Às vezes o snapshot é o comportamento certo (o pedido deve guardar o endereço da época da compra), e aí a duplicação é feature; a pergunta é se a cópia deveria mudar quando o original muda.
O argumento do ALTER TABLE envelheceu
Um argumento clássico a favor de documentos é que "adicionar um campo não exige ALTER TABLE em milhões de linhas". No PostgreSQL, isso deixou de ser verdade na versão 11: ADD COLUMN com default não volátil passou a ser só uma alteração de metadado, sem reescrever a tabela. Testei no PostgreSQL 17 com 1 milhão de linhas:
ALTER TABLE produtos ADD COLUMN ativo boolean NOT NULL DEFAULT true;
-- Time: 0.938 ms (o arquivo da tabela, pg_relation_filenode, não mudou)
O ganho real do MongoDB nessa frente não é o custo do ALTER. É poder conviver com formatos diferentes sem migração coordenada, o que é ótimo no começo de um produto e vira dívida quando ninguém sabe mais quais formatos existem na coleção.
Embutir ou referenciar: a decisão que define tudo
Dentro do próprio MongoDB existe a escolha que mais separa projetos saudáveis de projetos sofridos: embedding (aninhar) versus referencing (referenciar por id, no estilo chave estrangeira).
Embuta quando a relação é de contenção e o filho não vive sozinho: itens de um pedido, comentários de um post com pouco volume. Referencie quando o sub-objeto é grande, cresce sem limite ou é compartilhado por vários pais. A escolha do identificador também conta; os trade-offs de chave natural contra chave artificial do post sobre chave primária natural ou surrogate valem igual para o _id.
// Embedding: itens vivem dentro do pedido
db.pedidos.findOne({ _id: "ord_8821" }) // tudo em 1 leitura
// Referencing: comentários numa coleção própria
db.comentarios.find({ post_id: "post_42" }).limit(20)
// E quando precisa juntar, $lookup:
db.pedidos.aggregate([
{ $lookup: { from: "clientes", localField: "cliente.id", foreignField: "_id", as: "cli" } }
])
Documentos no MongoDB têm limite de 16 MB (o limite de tamanho de documento BSON). Uma lista que cresce para sempre, como o feed de atividades de um usuário ativo há anos, não pode ser embutida: vai estourar o documento. Na prática, esse limite é o seu detector de modelagem errada.
A escolha não é binária
Times maduros não escolhem "MongoDB ou PostgreSQL" para o sistema inteiro. Escolhem por contexto: catálogo de produtos em documentos, livro-razão financeiro no relacional, sessões e cache no Redis (o post sobre casos de uso do Redis cobre esse pedaço). Para a diferença mais ampla entre as famílias de banco, o comparativo banco relacional vs NoSQL trata a decisão num nível mais arquitetural. E se o projeto é pequeno o bastante para nem ter servidor de banco, o post sobre quando usar SQLite é a leitura certa.
O PostgreSQL, aliás, tem JSONB, que guarda documentos com índice GIN e operadores de contenção:
CREATE INDEX produtos_attrs_gin ON produtos USING gin (attrs jsonb_path_ops);
SELECT nome, preco FROM produtos WHERE attrs @> '{"tamanho": "M"}';
Para uma fatia pequena de dado flexível (os atributos variáveis do catálogo) dentro de um sistema majoritariamente relacional, isso resolve sem trazer um segundo banco para operar, fazer backup e monitorar.
Perguntas frequentes
Quando usar MongoDB em vez de um banco relacional?
Quando a entidade é lida e gravada como um bloco coeso, o schema varia entre registros, vários formatos precisam conviver ou você precisa de escala horizontal de escrita. Se o seu padrão de acesso é "pega o documento inteiro por uma chave", o modelo de documentos é direto e rápido.
Quando não usar MongoDB?
Quando o dado é uma rede de relações muitos-para-muitos consultada por vários ângulos, quando a regra de negócio depende de transações entre muitas entidades, ou quando relatórios e auditoria cruzam tudo com tudo. Se você está escrevendo $lookup em quase toda query, o dado é relacional.
MongoDB tem transações ACID?
Tem. Transações multi-documento existem desde a versão 4.0 em replica sets e desde a 4.2 em clusters shardados. A própria documentação avisa que elas custam mais que escritas em um documento só e não substituem um bom desenho de schema; por padrão, uma transação expira se passar de 60 segundos.
Dá para usar MongoDB e PostgreSQL no mesmo projeto?
Sim, e é comum. Use cada banco onde ele é forte: documentos para entidades autocontidas e de schema variável, relacional para o núcleo transacional e relatórios cruzados. Se a parte flexível é pequena, JSONB no próprio PostgreSQL costuma ser suficiente e poupa um banco a mais na operação.
Escolha pela forma do dado, não pela moda
O modelo de documentos não é "o futuro" nem "moda passageira": é uma escolha sobre a forma do seu dado. Pergunte se a entidade tem uma fronteira de agregação clara, se é lida como um bloco e se o limite de 16 MB dá folga. Se sim, MongoDB vai te servir bem, com validação de schema onde você precisar. Se você se vê reconstruindo JOINs com $lookup, sincronizando cópias na mão ou brigando com transações entre coleções, aquele dado queria ser uma tabela desde o começo. Quando vou inspecionar um documento real antes de decidir (um export do mongoexport ou a resposta de uma API), colo no JSON Formatter para enxergar a árvore inteira e ver o que de fato é lido junto.
- 01 Nota do PageSpeed influencia o SEO? 100/100 e reprovado O Google não usa a nota de 0 a 100 do PageSpeed no ranking, e sim os Core Web Vitals de usuários reais. Veja por que dá 100/100 e reprova no campo.
- 02 Teste unitário vs teste de integração: diferença na prática A diferença entre teste unitário e de integração com exemplos de API e banco de dados: o que cada um pega, quanto custa e quando usar cada um no seu projeto.