12 min de leitura
postgres
bases de dados
arquitectura
saas
escala

Postgres primeiro, base distribuída só quando dói

Sinais concretos para sair de Postgres, alternativas distribuídas, custos escondidos e erros comuns que tornam a migração pior do que o problema.

Engenheira apresenta métricas de base de dados a três colegas numa sala de reunião luminosa

TL;DR

  • Não migres de Postgres porque “vais crescer”. Migra quando já mediste limites claros: escrita saturada, latência p99 inaceitável, retenção de dados impossível ou requisitos reais de multi região.
  • PostgreSQL 16, bem afinado, com índices certos, particionamento, pooling e réplicas de leitura, aguenta muito mais do que a maioria dos produtos B2B precisa.
  • Bases distribuídas resolvem problemas específicos, mas trazem outros: transacções com retries, latência entre regiões, custos de operação, consistência diferente e debugging mais difícil.
  • As alternativas não são todas iguais. Citus, CockroachDB, YugabyteDB, Google Spanner e sharding manual têm compromissos muito diferentes.
  • A migração deve começar por uma matriz de decisão e por medições reais, não por uma preferência arquitectural.

O erro comum: confundir crescimento com necessidade de distribuição

A pergunta “quando migrar de Postgres para uma base de dados distribuída?” costuma aparecer cedo demais.

Em SaaS B2B, fintech, retail e plataformas internas, o padrão que vemos é simples: a equipa começa com PostgreSQL, o produto começa a ganhar uso, alguém lê sobre CockroachDB, Spanner ou YugabyteDB, e a conversa passa rapidamente de “temos uma query lenta” para “precisamos de uma base distribuída”.

Na maioria dos casos, não precisam.

Postgres continua a ser uma das escolhas mais fortes para produto digital em 2026. PostgreSQL 16 tem particionamento maduro, índices avançados, replication slots, logical replication, materialized views, JSONB competente, extensões úteis e tooling muito bom. Em cloud gerida, como AWS RDS, Aurora PostgreSQL, Google Cloud SQL ou Azure Database for PostgreSQL, ainda ganhas backups, failover, métricas e gestão de upgrades.

O problema é que Postgres é muitas vezes culpado por erros que não são da base de dados:

  • queries sem índices adequados;
  • ORMs a fazer N+1 queries;
  • falta de connection pooling;
  • transacções longas a bloquear tabelas;
  • jobs batch a competir com tráfego interactivo;
  • inexistência de cache onde faz sentido;
  • tabelas gigantes sem particionamento;
  • falta de observabilidade sobre p95, p99, locks e autovacuum.

Se tens 200 pedidos por segundo, 500 GB de dados e uma latência p99 de escrita a 80 ms, a resposta provável não é “base distribuída”. É medir melhor, corrigir queries, separar leituras pesadas, afinar índices e perceber onde está a contenção.

A minha opinião é forte: migrar cedo demais para uma base distribuída é uma forma cara de evitar trabalho disciplinado de engenharia.

Primeiro esgota o Postgres de forma séria

Antes de falares em distribuição, há uma lista curta de coisas que devem estar feitas. Não todas por dogma, mas as relevantes para o teu caso.

Primeiro, connection pooling. Se tens uma aplicação Node.js 22 LTS, Rails, Django ou Java a abrir centenas de ligações directas a Postgres, vais bater num limite que parece “escala” mas é apenas má gestão de ligações. PgBouncer em transaction pooling, ou o pooling gerido do teu fornecedor cloud, resolve muita coisa. Atenção: transaction pooling pode partir funcionalidades que dependem de estado de sessão, como prepared statements mal usados ou temporary tables.

Segundo, índices com base em queries reais. Não índices “porque parece”. Usa pg_stat_statements, disponível como extensão, e analisa as queries por tempo total, média, p95 aproximado e número de chamadas. A documentação oficial está em postgresql.org/docs/16/pgstatstatements.html. Uma query que demora 900 ms e corre 3 vezes por dia pode ser menos grave do que uma query de 40 ms que corre 2 milhões de vezes.

Terceiro, separa leituras de escrita quando isso é aceitável. Réplicas de leitura ajudam em dashboards, exports, relatórios e APIs com tolerância a atraso de alguns segundos. Mas não resolvem escrita. Se o problema é contenção no primário, mais réplicas não ajudam.

Quarto, particionamento. PostgreSQL 16 suporta declarative partitioning com bom comportamento para tabelas por data, tenant ou região lógica. É útil quando tens tabelas com centenas de milhões de linhas, retenção por período ou queries que naturalmente filtram por chave. Mas particionamento mal feito piora tudo. A armadilha clássica é particionar por uma coluna que as queries não usam no filtro. Ficas com mais complexidade e o planner continua a varrer partições a mais.

Quinto, trabalhos assíncronos. Muitas equipas metem tudo na transacção HTTP: criar entidade, calcular métricas, enviar eventos, actualizar agregados, escrever audit log e notificar sistemas externos. Depois culpam Postgres. Um outbox pattern com uma fila, por exemplo SQS, RabbitMQ, Kafka ou Redis Streams, pode reduzir a latência p99 de um endpoint de 700 ms para menos de 150 ms sem mudar de base de dados.

Sexto, gestão de autovacuum. Em tabelas com muitas actualizações, o bloat mata performance. Se nunca olhaste para dead tuples, vacuum lag, freeze age e tamanho real dos índices, ainda não tens dados para defender uma migração.

Sinais de que Postgres está mesmo a deixar de chegar

Há situações em que Postgres deixa de ser a melhor ferramenta. O ponto é reconhecer sinais reais, não ansiedade.

Um sinal sério é saturação persistente de escrita. Por exemplo: CPU do primário acima de 70 por cento durante horas de pico, IOPS no limite, WAL a crescer de forma agressiva, checkpoints frequentes e latência p99 de commits acima de 200 ms mesmo depois de optimização. Se a tua carga é dominada por escrita concorrente e não consegues dividi-la por filas, agregações assíncronas ou particionamento, distribuição pode fazer sentido.

Outro sinal é contenção numa hot row ou num pequeno conjunto de linhas. Contadores globais, saldos agregados, inventário centralizado e quotas partilhadas podem criar filas de transacções. Aqui, a base distribuída nem sempre salva. Muitas vezes é preciso redesenhar o modelo de dados. Um contador global fortemente consistente continua a ser um gargalo, esteja em Postgres ou numa base distribuída.

Terceiro, requisitos reais de multi região. “Queremos estar na Europa e nos Estados Unidos” não chega. A pergunta é: precisas de escrita local em mais do que uma região com RPO próximo de zero? Precisas de sobreviver à perda de uma região sem failover manual? Tens utilizadores em continentes diferentes com p99 abaixo de 100 ms? Se sim, Postgres primário único começa a doer.

Quarto, volume operacional. Se tens 10 TB ou 50 TB de dados activos, com crescimento mensal forte, backups lentos, restores que demoram muitas horas e manutenção cada vez mais arriscada, a questão já não é só performance. É operabilidade. Uma base distribuída pode repartir storage e computação, mas também aumenta o número de peças que podem falhar.

Quinto, requisitos de isolamento por cliente. Em SaaS multicliente, às vezes o problema não é a escala global, é o maior cliente dominar recursos. Podes resolver com schema por cliente, base por cliente, particionamento por tenant ou sharding. Saltar directamente para CockroachDB ou Spanner pode ser excessivo.

Regra prática: se ainda não consegues explicar o problema com métricas de p95, p99, throughput de escrita, IOPS, locks, tamanho de tabelas, crescimento mensal e RTO, ainda não estás pronto para escolher uma base distribuída.

Alternativas reais e compromissos

“Base distribuída” é uma categoria larga demais. As opções resolvem problemas diferentes.

OpçãoQuando faz sentidoPontos fortesCustos e riscos
PostgreSQL gerido com réplicasMaioria dos SaaS B2B até escala sériaSimples, conhecido, bom ecossistema, SQL completoEscrita continua centralizada, failover tem limites
PostgreSQL com CitusDados naturalmente distribuíveis por tenant ou chaveMantém muito do ecossistema Postgres, bom para multiclienteJoins entre shards podem ficar caros, modelo tem de encaixar
CockroachDB 24.2Escrita distribuída, tolerância a falhas, SQL distribuídoConsistência forte, sobrevivência a nós e regiões, API parecida com PostgresTransacções podem abortar e exigir retries, latência entre regiões conta
YugabyteDB 2.xAplicações SQL com distribuição horizontalCompatibilidade PostgreSQL interessante, boa opção para cloud privadaOperação mais exigente, compatibilidade não é 100 por cento
Google SpannerMulti região com consistência forte e operação geridaSLA e modelo global muito maduros, bom para cargas críticasVendor lock in forte, custo e desenho de schema exigentes
Sharding manual em PostgresEscala por tenant ou domínio com equipa séniorControlo máximo, mantém PostgresComplexidade na aplicação, migrações e queries globais difíceis

Citus merece atenção quando o teu SaaS é naturalmente dividido por tenant. Se quase todas as queries têm tenant_id, distribuir por essa chave pode funcionar bem. Mas se tens relatórios globais constantes, joins entre tenants ou pesquisa transversal pesada, vais pagar a factura.

CockroachDB é uma boa escolha quando precisas de tolerância a falhas e SQL distribuído com consistência forte. Mas a compatibilidade com Postgres não significa comportamento igual. A documentação oficial em cockroachlabs.com/docs/v24.2 é clara sobre transaction retries. O teu código tem de estar preparado para repetir transacções. Muitos ORMs não estão preparados sem trabalho explícito.

YugabyteDB é interessante para equipas que querem um modelo próximo de PostgreSQL mas com distribuição. Ainda assim, é uma base de dados com operação própria. Não a trataria como “Postgres com mais escala”. Essa mentalidade cria incidentes.

Spanner, documentado em cloud.google.com/spanner/docs, é forte quando a empresa aceita o ecossistema Google Cloud e precisa mesmo de multi região consistente. Não é uma escolha neutra. O modelo de custos, desenho de chaves e latência de commits têm de ser compreendidos antes.

Sharding manual continua válido. Pouco elegante, mas eficaz. Para SaaS B2B, dividir clientes grandes por bases separadas pode ser mais simples do que meter toda a plataforma numa base distribuída. Também melhora isolamento, backups por cliente e requisitos de compliance. O custo é perder queries globais fáceis.

O que muda na aplicação quando distribuis a base de dados

A maior ilusão é pensar que a migração é só trocar o driver.

Numa base distribuída, a localização dos dados importa. Se fazes uma transacção que toca em linhas espalhadas por várias regiões ou shards, vais pagar em latência. A velocidade da luz não perdoa arquitectura. Uma ida e volta Europa para Estados Unidos pode adicionar 70 ms a 120 ms antes de qualquer trabalho útil. Se o teu commit precisa de consenso entre regiões, a latência p99 sobe.

Também muda a forma como desenhas chaves primárias. IDs sequenciais podem criar hotspots. Em algumas bases distribuídas, usar chaves monotónicas concentra escrita numa zona do cluster. UUIDs aleatórios reduzem hotspots, mas pioram localidade e índices. ULIDs e UUIDv7 podem ser bons compromissos, mas dependem da base e do padrão de acesso.

As transacções passam a exigir disciplina. Em CockroachDB, por exemplo, erros de serialização são parte normal do modelo sob concorrência. A aplicação tem de repetir a transacção completa. A armadilha comum que vejo em produção é repetir apenas a query que falhou, quando a unidade correcta é a transacção inteira. Se dentro dessa transacção já chamaste uma API externa, enviaste um email ou publicaste um evento, podes duplicar efeitos. Por isso, outbox pattern e idempotência deixam de ser “boas práticas” e passam a ser requisitos.

Migrações de schema também ficam mais sensíveis. Adicionar uma coluna pode ser simples. Alterar índices globais numa tabela enorme pode ter impacto grande. Criar uma constraint única global pode exigir coordenação cara. Algumas bases suportam online schema changes, mas “online” não significa “sem custo”.

Observabilidade tem de subir de nível. Em Postgres olhas para locks, queries lentas, autovacuum, WAL e replication lag. Numa base distribuída também precisas de perceber ranges, tablets, leases, consensus latency, hotspots, rebalanceamento e tráfego entre zonas. Se a equipa não tem maturidade operacional, vais trocar um problema conhecido por cinco problemas novos.

Matriz de decisão prática

Eu usaria esta matriz antes de aprovar uma migração.

  • Se o problema principal é leitura pesada, tenta réplicas, cache, materialized views e índices antes.
  • Se o problema é escrita centralizada mas por tenant, avalia Citus ou sharding por tenant.
  • Se o problema é disponibilidade regional com escrita em várias regiões, avalia CockroachDB, YugabyteDB ou Spanner.
  • Se o problema é um cliente enorme a afectar todos os outros, considera isolamento por base de dados ou cluster dedicado.
  • Se o problema é compliance e residência de dados, particionamento por região ou base por região pode ser suficiente.
  • Se o problema é apenas “queremos estar preparados”, não migres.

Também colocaria limites quantitativos para evitar decisões emocionais:

  • abaixo de 1 TB de dados activos, a migração raramente se justifica só por volume;
  • abaixo de 300 escritas por segundo sustentadas, Postgres bem afinado costuma ter margem;
  • p99 de leitura acima de 500 ms deve ser investigado antes de culpar a base;
  • p99 de commit acima de 200 ms, com IOPS e CPU saturados, já merece análise séria;
  • RTO inferior a 5 minutos e RPO perto de zero entre regiões pode justificar arquitectura distribuída;
  • crescimento acima de 30 por cento ao mês em storage activo pede plano antes de virar incidente.

Estes números não são leis. São pontos de partida para uma conversa técnica. Uma fintech com saldos e auditoria tem tolerância diferente de uma plataforma de conteúdos. Um eCommerce em campanha tem picos diferentes de uma aplicação interna usada das 9h às 18h.

O mais importante é fazer uma prova de conceito com o teu padrão real de dados. Não com dados sintéticos perfeitos. Usa tabelas largas, índices reais, queries feias, tenants grandes e tráfego parecido com produção. Mede p50, p95, p99, abortos de transacção, custo por hora, tempo de restore e complexidade de deploy.

Como migrar sem partir o produto

Se a decisão for migrar, trata isto como programa de engenharia, não como tarefa de infra.

Começa por reduzir acoplamento. Identifica bounded contexts onde a base pode mudar sem reescrever tudo. Catálogo, auditoria, eventos, reporting e sessões têm perfis diferentes. Não precisas de migrar tudo no mesmo dia.

Depois, estabiliza contratos de dados. APIs internas, eventos versionados e outbox ajudam a separar a aplicação da persistência. Se o teu código tem SQL espalhado por 80 serviços ou por 300 ficheiros, a migração vai expor essa dívida.

Segue com dual writes apenas se souberes lidar com inconsistência. Dual write directo é perigoso: escreves em Postgres, falha a escrita na nova base, e agora tens divergência. Melhor usar change data capture, por exemplo logical decoding em Postgres, Debezium ou ferramentas nativas do fornecedor, com reconciliação explícita.

Planeia backfill como operação de produção. Copiar 2 TB não é só “correr um script”. Tens throttling, locks, custo de rede, verificação, checksums, reprocessamento e janelas de corte. Um backfill que consome IOPS do primário pode degradar a aplicação principal.

Define rollback antes do cutover. Se a nova base falhar no primeiro dia, consegues voltar? Durante quanto tempo manténs escrita compatível? Como resolves dados criados depois do corte? Estas perguntas têm de estar respondidas antes.

E não ignores a equipa. Uma base distribuída sem pessoas capazes de a operar é risco. Se ninguém sabe interpretar um hotspot, um aumento de latency no consensus path ou um rebalanceamento mal sucedido, vais depender cegamente do fornecedor.

Conclusão

Postgres deve ser a escolha por defeito durante mais tempo do que muita gente quer admitir. A migração para uma base distribuída faz sentido quando há limites medidos, requisitos regionais reais ou isolamento que Postgres já não resolve bem.

A decisão certa raramente é “Postgres ou distribuído”. É escolher o menor sistema que resolve o problema sem criar uma plataforma que a equipa não consegue operar.

Se estás a enfrentar um problema parecido, marca uma conversa em https://impact-origin.com/agendamento.

Impact OriginGostaste deste artigo?Na Impact Origin ajudamos fundadores e equipas a construir e escalar software à medida, do MVP da startup ao próximo passo. Se tens um projeto em mente, vamos falar.