Banco de dados em tempo real: Supabase vs PlanetScale vs Neon

1. Introdução ao ecossistema de bancos de dados em tempo real

A demanda por sincronização em tempo real em aplicações modernas cresceu exponencialmente. Chats colaborativos, dashboards de monitoramento ao vivo, editores de documentos compartilhados e jogos multiplayer exigem que os dados fluam instantaneamente entre servidores e clientes. Nesse cenário, três plataformas emergiram como protagonistas: Supabase, PlanetScale e Neon.

Cada uma oferece uma abordagem distinta para bancos de dados relacionais com capacidades de tempo real:

  • Supabase: Ecossistema completo sobre PostgreSQL, com servidor Realtime nativo baseado em WebSockets e replicação lógica (CDC).
  • PlanetScale: MySQL compatível com modelo de branching para desenvolvimento seguro, mas sem suporte nativo a WebSockets — requer camadas extras para tempo real.
  • Neon: PostgreSQL serverless com pooling inteligente, suporte a LISTEN/NOTIFY nativo e arquitetura compute-storage separada.

Os critérios de comparação incluem latência de subscrição, escalabilidade, modelo de dados, custo operacional e complexidade de implementação.

2. Supabase: o ecossistema completo sobre Postgres

Supabase é frequentemente chamado de "Firebase de código aberto". Sua arquitetura de tempo real é baseada no Realtime Server, que utiliza WebSockets e replicação lógica (CDC) do PostgreSQL. Isso permite que qualquer mudança no banco seja transmitida instantaneamente para os clientes inscritos.

// Exemplo: Inscrição em tempo real com Supabase JavaScript
import { createClient } from '@supabase/supabase-js'

const supabase = createClient('https://seu-projeto.supabase.co', 'sua-chave')

// Inscrever em mudanças na tabela "mensagens"
const subscription = supabase
  .channel('mensagens-channel')
  .on('postgres_changes',
    { event: 'INSERT', schema: 'public', table: 'mensagens' },
    (payload) => {
      console.log('Nova mensagem:', payload.new)
    }
  )
  .subscribe()

Funcionalidades nativas incluem subscriptions (inscrições em eventos de banco), presence (quem está online), broadcast (mensagens entre clientes) e filas de mensagens. Casos de uso ideais são aplicações que precisam de backend integrado com auth, storage e edge functions, combinados com dados reativos.

3. PlanetScale: branch-based MySQL com replicação global

PlanetScale adota um modelo inovador de branching de banco de dados. Cada branch é um ambiente isolado com seu próprio esquema e dados, permitindo alterações de schema sem downtime. O suporte a tempo real, porém, é indireto.

// Exemplo: Polling otimizado com PlanetScale e WebSocket proxy
// (camada extra necessária para tempo real)

// Servidor WebSocket usando PlanetScale como fonte
const WebSocket = require('ws')
const mysql = require('mysql2/promise')

const pool = mysql.createPool('mysql://user:pass@aws.connect.psdb.cloud/meu-banco?ssl={"rejectUnauthorized":true}')

const wss = new WebSocket.Server({ port: 8080 })

wss.on('connection', (ws) => {
  // Polling inteligente a cada 2 segundos
  const interval = setInterval(async () => {
    const [rows] = await pool.query('SELECT * FROM mensagens WHERE created_at > NOW() - INTERVAL 2 SECOND')
    if (rows.length > 0) {
      ws.send(JSON.stringify(rows))
    }
  }, 2000)

  ws.on('close', () => clearInterval(interval))
})

A ausência de WebSockets nativos é uma limitação significativa. Para aplicações que exigem tempo real, é necessário adicionar uma camada extra como um proxy WebSocket ou implementar polling inteligente. PlanetScale brilha em cenários de alto volume de escritas e necessidade de branches para desenvolvimento paralelo.

4. Neon: Postgres serverless com pooling e cold starts evitados

Neon separa compute (processamento) de storage (armazenamento), permitindo escalar horizontalmente de forma automática. Seu suporte a tempo real utiliza o mecanismo nativo LISTEN/NOTIFY do PostgreSQL, combinado com WebSockets via drivers especializados.

// Exemplo: LISTEN/NOTIFY com Neon e WebSocket
const { Pool } = require('pg')
const WebSocket = require('ws')

const pool = new Pool({
  connectionString: 'postgres://user:pass@ep-frosty-rain-123456.us-east-2.aws.neon.tech/neondb?sslmode=require'
})

const wss = new WebSocket.Server({ port: 8080 })

wss.on('connection', async (ws) => {
  const client = await pool.connect()
  await client.query('LISTEN novas_mensagens')

  client.on('notification', (msg) => {
    ws.send(msg.payload)
  })

  ws.on('close', () => {
    client.release()
  })
})

Vantagens incluem escalabilidade horizontal automática, zero-downtime para escalar e ideal para aplicações serverless com tráfego imprevisível. O cold start é gerenciado com pooling inteligente, mantendo conexões aquecidas para LISTEN/NOTIFY.

5. Comparação prática: desempenho e latência

Testes de latência de subscrição revelam diferenças significativas:

  • Supabase Realtime: latência típica de 50-150ms para eventos CDC, com overhead de WebSocket.
  • Neon LISTEN/NOTIFY: latência de 20-80ms, pois o mecanismo é nativo do Postgres e não requer camadas extras.
  • PlanetScale polling: latência mínima de 2 segundos (intervalo de polling), podendo chegar a 5-10 segundos dependendo da configuração.

O impacto da localização geográfica é relevante: Supabase e Neon oferecem múltiplas regiões, enquanto PlanetScale tem disponibilidade global via AWS, GCP e Azure.

Quanto ao custo por conexão simultânea:

Plataforma Plano gratuito Conexões simultâneas Armazenamento gratuito
Supabase Sim 200 (WebSocket) 500 MB
PlanetScale Sim 1.000 (banco) 1 GB
Neon Sim 100 (compute) 500 MB

6. Armadilhas e boas práticas de implementação

Supabase: Limite de 200 conexões WebSocket concorrentes no plano gratuito pode ser um gargalo. Gerencie filas com channel.unsubscribe() para liberar recursos.

// Boa prática: gerenciar inscrições no Supabase
const channel = supabase.channel('meu-canal')
// ... configurar eventos
channel.subscribe()

// Importante: limpar ao desmontar componente
window.addEventListener('beforeunload', () => {
  supabase.removeChannel(channel)
})

PlanetScale: Polling excessivo pode gerar custos elevados de consultas. Use Deploy Requests para dados mutáveis e implemente cache local para reduzir chamadas.

// Evitar polling a cada segundo
// Preferir intervalos de 3-5 segundos para dados não críticos

Neon: Cold starts em funções serverless podem atrasar a primeira conexão. Configure pooling com pg-pool e mantenha conexões aquecidas.

// Configuração de pooling para Neon
const pool = new Pool({
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 10000,
})

Padrões de segurança incluem Row Level Security (RLS) no Supabase e autenticação JWT no Neon.

7. Guia de decisão: qual escolher para cada cenário?

Aplicações colaborativas em tempo real (docs, boards, chats): Supabase é a melhor escolha pelo custo-benefício, oferecendo subscriptions nativas, presença e broadcast em um único ecossistema.

Sistemas com alto volume de escritas e necessidade de branching (e-commerce, SaaS): PlanetScale se destaca com branches isolados para desenvolvimento e deploy seguro de schemas.

Apps serverless com tráfego imprevisível e orçamento restrito: Neon oferece escalabilidade automática com pagamento por uso, ideal para startups e MVPs.

Matriz de decisão rápida:

Critério Supabase PlanetScale Neon
Tempo real nativo ✅ Excelente ❌ Precisa de camada extra ✅ Bom
Escalabilidade ✅ Boa ✅ Excelente ✅ Excelente
Ecossistema ✅ Completo ⚠️ Limitado ⚠️ Básico
Custo inicial ✅ Grátis generoso ✅ Grátis generoso ✅ Grátis generoso
Maturidade ✅ Maduro ✅ Maduro ⚠️ Em crescimento

8. Conclusão e tendências futuras

Cada plataforma tem forças e fraquezas claras. Supabase oferece o ecossistema mais completo para tempo real, PlanetScale é imbatível em branching e escalabilidade de escritas, e Neon se destaca para cargas serverless imprevisíveis.

O futuro do banco de dados em tempo real aponta para integração com edge computing e WebSockets nativos em todas as plataformas. Supabase já investe em edge functions, Neon expande sua rede global de computes, e PlanetScale deve eventualmente adicionar suporte nativo a streaming.

Para startups que precisam de tempo real crítico, Supabase é a recomendação. Para empresas com alto volume de dados e necessidade de branches, PlanetScale. Para apps serverless com orçamento enxuto, Neon. A escolha final depende do perfil do projeto e da maturidade da equipe.

Referências