English summary: Design streaming architectures (Kafka, WebSockets, serverless) for real-time analytics/notifications.
Realtime Streaming Architectures: WebSockets, Server-Sent Events e Kafka
Polling a cada segundo desperdiça recursos. Realtime streaming envia dados instantaneamente quando disponíveis.
Técnicas de Realtime
1. Polling (❌ Ineficiente)
setInterval(async () => {
const response = await fetch('/api/messages');
const messages = await response.json();
updateUI(messages);
}, 1000);
2. Long Polling
async function longPoll() {
const response = await fetch('/api/messages?timeout=30');
const messages = await response.json();
updateUI(messages);
longPoll();
}
3. Server-Sent Events (SSE)
const eventSource = new EventSource('/api/stream');
eventSource.onmessage = (event) => {
const data = JSON.parse(event.data);
updateUI(data);
};
app.get('/api/stream', (req, res) => {
res.setHeader('Content-Type', 'text/event-stream');
res.setHeader('Cache-Control', 'no-cache');
res.setHeader('Connection', 'keep-alive');
setInterval(() => {
const data = { timestamp: Date.now(), value: Math.random() };
res.write(`data: ${JSON.stringify(data)}\n\n`);
}, 1000);
});
Vantagens: HTTP simples, auto-reconnect
Desvantagens: Unidirecional (server → client)
4. WebSockets (Bidirecional)
const ws = new WebSocket('ws://localhost:3000');
ws.onopen = () => {
ws.send(JSON.stringify({ type: 'subscribe', channel: 'chat' }));
};
ws.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log('Received:', data);
};
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 3000 });
wss.on('connection', (ws) => {
ws.on('message', (message) => {
const data = JSON.parse(message);
wss.clients.forEach((client) => {
if (client.readyState === WebSocket.OPEN) {
client.send(JSON.stringify({ type: 'message', data }));
}
});
});
});
##Kafka: Event Streaming em Escala
const { Kafka } = require('kafkajs');
const kafka = new Kafka({
clientId: 'my-app',
brokers: ['localhost:9092']
});
const producer = kafka.producer();
await producer.connect();
await producer.send({
topic: 'user-events',
messages: [
{value:JSON.stringify({ userId: '123', action: 'login' }) }
]
});
const consumer = kafka.consumer({ groupId: 'analytics-group' });
await consumer.subscribe({ topic: 'user-events' });
await consumer.run({
eachMessage: async ({ message }) => {
const event = JSON.parse(message.value.toString());
console.log('Event:', event);
}
});
Quando Usar Cada Técnica
| Técnica | Quando Usar |
|---|
| SSE | Notificações, dashboards (server → client) |
| WebSockets | Chat, multiplayer games (bidirecional) |
| Kafka | Event sourcing, analytics (milhões eventos/s) |
Conclusão
Polling é antipattern. Use SSE para server push, WebSockets para bidirectional, e Kafka para massive scale.
Referências
- MDN - Server-Sent Events
- WebSocket Protocol Spec (RFC 6455)
- Kafka Documentation
Caso real e métricas
Cenário: Aplicativo de logística em tempo real.
LogiTrack construiu pipeline Kafka → Flink → WebSockets com DLQ e análise tempo real.
| Métrica | Antes | Depois |
|---|
| Latência de eventos | 5s | 200ms |
| Perdas de mensagens | 2% | 0.02% |
| Tempo para adicionar consumidor | 1 semana | 6h |
Checklist de implementação
- Escolha backbone (Kafka, Pulsar) conforme throughput.
- Separe ingestão, processamento, entrega.
- Implemente DLQ e reprocessamento.
- Monitore lag e atrasos.
Referências rápidas
- Confluent Streaming Guides
- Uber real-time infra talk
Realtime Não É Um Recurso
Realtime costuma ser vendido como uma feature.
Isso é um erro de linguagem.
Realtime é uma propriedade de arquitetura.
Ela atravessa API.
Ela atravessa frontend.
Ela atravessa backend.
Ela atravessa infraestrutura.
Ela atravessa produto.
Se você trata realtime como um botão, vai criar um sistema que parece vivo e quebra como um brinquedo.
Se você trata realtime como contrato de entrega, começa a fazer escolhas que sobrevivem ao crescimento.
A pergunta certa
- O dado precisa chegar imediatamente?
- O dado precisa chegar em ordem?
- O dado precisa chegar para todos?
- O dado precisa chegar para um usuário específico?
- O dado precisa sobreviver a reconexão?
- O dado precisa ser auditável?
- O dado precisa ser consumido por múltiplos clientes?
- O dado precisa ser retido?
- O dado precisa ser reprocessado?
- O dado precisa ser filtrado?
A consequência da resposta
Se a resposta for "não", não force WebSocket.
Se a resposta for "sim, mas só no sentido servidor para cliente", SSE é frequentemente suficiente.
Se a resposta for "sim, bidirecional e interativo", WebSocket faz sentido.
Se a resposta for "sim, massivo e durável", Kafka entra na conversa.
Se a resposta for "sim, confiável e com ordenação por partição", você está falando de event streaming, não de simples push.
A Escada De Latência
Nem toda aplicação precisa ser instantânea.
Mas toda aplicação sente latência.
1. Latência aceitável
- Relatórios.
- Admin dashboards.
- Backoffice.
- Rotinas noturnas.
- Processos sem interação humana.
2. Latência perceptível
- Likes.
- Notifications.
- Typing indicators.
- Progress bars.
- Chat lists.
3. Latência crítica
- Trading.
- Telemetria.
- Dispatch.
- Fraud detection.
- Multiplayer.
- Collaboration.
4. Latência fatal
- Alarmes.
- Segurança.
- Operação de incidentes.
- Integração em tempo real entre sistemas críticos.
O problema não é querer ser rápido.
O problema é confundir urgência de negócio com urgência de engenharia.
Matriz De Protocolo
| Técnica | Direção | Persistência | Ordenação | Custo Operacional | Melhor Uso |
|---|
| Polling | Cliente -> Servidor | Nenhuma | Baixa | Alto | Só quando não há alternativa |
| Long Polling | Cliente -> Servidor | Baixa | Baixa | Médio | Integrações simples |
| SSE | Servidor -> Cliente | Baixa | Média | Baixo | Notificações e dashboards |
| WebSocket | Bidirecional | Baixa | Média | Médio | Chat e colaboração |
| Kafka | Broker -> Consumidores | Alta | Alta por partição | Alto | Event streams e pipelines |
| Pulsar | Broker -> Consumidores | Alta | Alta | Alto | Multitenancy e geo-distribuição |
| Redis Streams | Broker leve | Média | Média | Médio | Filas e fanout controlado |
| WebTransport | Bidirecional | Baixa | Média | Médio | Futuro da interação em browsers modernos |
Leitura da matriz
O protocolo não resolve tudo.
Ele só remove uma classe de problema.
SSE remove complexidade desnecessária quando o canal é unidirecional.
WebSocket remove polling quando a conversa precisa ser interativa.
Kafka remove acoplamento quando durabilidade e replay importam.
Pulsar remove algumas dores de multitenancy e geo-replicação.
Redis Streams remove peso quando o caso de uso é interno e moderado.
Quando Polling Ainda Faz Sentido
Polling é mal visto, mas não é sempre errado.
- Se o dado muda raramente.
- Se o custo de manter conexão é maior que o benefício.
- Se o volume é baixo.
- Se a simplicidade é a prioridade.
- Se o dispositivo é limitado.
- Se a infraestrutura é hostil a conexões longas.
O que o polling esconde
Polling parece simples.
Na prática, ele cria falso conforto.
- Mais requests.
- Mais load.
- Mais vazamento de bateria.
- Mais ruído de métricas.
- Mais custo de rede.
- Mais CPU desperdiçada.
O sinal é claro:
se você está consultando o mesmo dado a cada segundo sem motivo, talvez esteja pagando caro por preguiça de design.
SSE Em Produção
SSE é subestimado porque parece simples demais.
Mas simplicidade aqui é vantagem.
- Usa HTTP.
- Passa por proxies com menos dor.
- Reconecta sozinho.
- É fácil de depurar.
- Serve bem notificações.
- Serve bem dashboards.
- Serve bem feeds que não exigem resposta do cliente.
Limites de SSE
- É unidirecional.
- Não é para chat interativo.
- Não é para edição colaborativa pesada.
- Não é para controle de sessão sofisticado.
- Não é para payloads muito volumosos.
Exemplo operacional
import express from "express";
const app = express();
app.get("/events", (req, res) => {
res.setHeader("Content-Type", "text/event-stream");
res.setHeader("Cache-Control", "no-cache");
res.setHeader("Connection", "keep-alive");
let count = 0;
const timer = setInterval(() => {
count += 1;
res.write(`event: heartbeat\n`);
res.write(`data: ${JSON.stringify({ count, ts: Date.now() })}\n\n`);
}, 1000);
req.on("close", () => {
clearInterval(timer);
res.end();
});
});
WebSocket Em Produção
WebSocket resolve o problema quando o cliente também precisa falar.
Mas ele traz uma verdade inconveniente:
conexões persistentes mudam tudo.
- Estado de sessão aparece.
- Heartbeat aparece.
- Reconnect aparece.
- Backpressure aparece.
- Presence aparece.
- Fanout aparece.
- Escalabilidade horizontal fica mais difícil.
Boas práticas
- Defina o schema da mensagem.
- Separe eventos de comando.
- Valide payload de entrada.
- Rejeite frames inválidos.
- Envie ping/pong.
- Corte conexões zumbis.
- Publique métricas de conexão.
- Controle rate limit por usuário.
- Controle rate limit por IP.
- Use sticky sessions quando necessário.
Exemplo operacional
import { WebSocketServer } from "ws";
const wss = new WebSocketServer({ port: 3001 });
wss.on("connection", (socket, request) => {
socket.send(JSON.stringify({ type: "connected" }));
socket.on("message", (raw) => {
const message = JSON.parse(raw.toString());
if (message.type === "subscribe") {
socket.send(JSON.stringify({ type: "subscribed", channel: message.channel }));
return;
}
if (message.type === "ping") {
socket.send(JSON.stringify({ type: "pong", ts: Date.now() }));
return;
}
});
socket.on("close", () => {
console.log("socket closed");
});
});
Kafka Não É WebSocket
Kafka resolve outro problema.
Ele não existe para conversar com o browser.
Ele existe para absorver, persistir e distribuir eventos de forma confiável.
O que Kafka faz bem
- Durabilidade.
- Replay.
- Retenção.
- Fan-out.
- Desacoplamento.
- Escala por partição.
- Consumo múltiplo.
- Reprocessamento.
- Auditoria.
- Integração de sistemas.
O que Kafka faz mal
- Baixa latência para UX de browser.
- Complexidade operacional sem equipe madura.
- Queries ad hoc.
- Estados efêmeros de interface.
- Interação direta com o cliente final.
Um padrão mais útil
- Browser usa SSE ou WebSocket.
- Backend publica evento.
- Kafka carrega a verdade durável.
- Stream processor enriquece dados.
- Consumidores diferentes fazem trabalhos diferentes.
Checklist De Decisão
- O consumidor é navegador? prefira SSE ou WebSocket.
- O consumidor é serviço interno? considere Kafka.
- O fluxo precisa ser bidirecional? WebSocket.
- O fluxo é só notificação? SSE.
- O dado precisa de replay? Kafka.
- O dado precisa de ordenação por chave? Kafka.
- O dado precisa sobreviver a desligamento do cliente? Kafka.
- O dado precisa de reconexão automática simples? SSE.
- O dado precisa de comandos de volta do cliente? WebSocket.
- O dado precisa de fan-out massivo? Kafka.
- O dado precisa de simplicidade? SSE.
- O dado precisa de controle fino de sessão? WebSocket.
Delivery Semantics Em Detalhe
Entrega sem semântica é sorte com embalagem.
- At-most-once é útil quando perder é aceitável.
- At-least-once é útil quando repetir é aceitável.
- Exactly-once é útil quando o domínio paga o custo.
- Idempotência é mais barata que perfeição.
- Deduplicação é mais barata que investigação manual.
- Sequenciamento por chave é mais útil que ordem global.
- Replay é poderoso, mas caro.
- Retenção longa é útil para auditoria.
- Retenção curta é útil para custo.
- ACK deve responder ao contrato.
- NACK deve acionar política.
- Retry deve ter limite.
- Backoff deve ter jitter.
- Deadline deve ser explícito.
- Expiração deve ser prevista.
- Versionamento deve acompanhar o schema.
- Compatibilidade reversa deve ser obrigatória.
- Payload grande deve ser excepcional.
- Compressão deve ser medida.
- Batch deve ser intencional.
Backpressure Sem Mito
Backpressure é a frase elegante para "pare de produzir mais do que consegue consumir".
- O produtor precisa respeitar o consumidor.
- O broker precisa absorver picos previsíveis.
- O frontend precisa evitar atualização excessiva.
- O worker precisa reduzir velocidade quando o downstream cai.
- O cliente precisa lidar com buffers.
- O websocket precisa fechar conexões zumbis.
- O SSE precisa suportar reconexão limpa.
- O Kafka precisa revelar lag.
- O balancer precisa distribuir carga.
- O autoscaler precisa olhar sinais corretos.
Onde o backpressure aparece
- No socket.
- No buffer.
- Na fila.
- No heap.
- No render loop.
- No batch processor.
- No broker.
- No consumer group.
- No HTTP timeout.
- No retry policy.
Topic Design
Um tópico bem desenhado evita metade da dor.
- Nomeie pelo domínio.
- Particione pela chave que importa.
- Evite partição aleatória sem motivo.
- Evite tópicos genéricos demais.
- Evite payload que misture contextos.
- Evite evento com responsabilidade dupla.
- Evite tópico sem retenção clara.
- Evite esquema sem contrato.
- Evite consumo sem DLQ.
- Evite fan-out sem intenção.
Perguntas que o tópico deve responder
- Quem produz?
- Quem consome?
- Qual a ordem esperada?
- Qual o tamanho esperado?
- Qual a retenção?
- Qual o SLA?
- Qual o volume de pico?
- Qual o comportamento em queda?
- Qual o plano de replay?
- Qual o plano de purge?
Observabilidade Que Ajuda
Streaming sem observabilidade é uma caixa de fumaça.
- Lag por partição.
- Lag por consumer group.
- Taxa de reconnect.
- Taxa de error frame.
- Taxa de retry.
- Taxa de duplicate delivery.
- Latência end to end.
- Tamanho médio de payload.
- Throughput por canal.
- Conexões ativas.
Traces úteis
- Do HTTP request ao publish.
- Do publish ao broker.
- Do broker ao consumer.
- Do consumer à resposta.
- Do websocket ao UI update.
- Do SSE ao render.
- Do Kafka ao indexador.
- Do indexador ao dashboard.
Logs úteis
- Mensagem rejeitada.
- Schema inválido.
- Auth falhou.
- Replay iniciado.
- Replay concluído.
- Dead letter emitida.
- Retry executado.
- Channel desconectado.
- Heartbeat perdido.
- Consumer reassigned.
Segurança E Abuso
Conexões longas aumentam a superfície de risco.
- Autentique no handshake.
- Autorize por canal.
- Revogue rápido.
- Rate limit por identidade.
- Rate limit por IP.
- Limite payload.
- Limite conexão por usuário.
- Proteja contra replay.
- Proteja contra injection.
- Proteja contra abuso de fan-out.
Questões obrigatórias
- O token expira?
- A reconexão respeita autorização?
- O cliente pode escutar canais indevidos?
- O broker está isolado?
- O schema impede payload malicioso?
- O gateway valida origem?
- O admin consegue auditar?
- A retenção respeita privacidade?
- O PII está mascarado?
- O canary está protegido?
Failure Modes Mais Comuns
- Duplicação silenciosa.
- Perda silenciosa.
- Ordem quebrada.
- Partição quente.
- Consumer preso.
- Lag crescente.
- Reconnect storm.
- Retry storm.
- Payload fora do contrato.
- Timeout em cascata.
- WebSocket sem heartbeat.
- SSE sem reconexão útil.
- Kafka sem retenção útil.
- DLQ sem monitoramento.
- Cache desatualizado.
- Broadcast fora de controle.
- Estado divergente entre cliente e servidor.
- Observabilidade ausente.
- Alert fatigue.
- Escala sem necessidade.
Blueprint De Produção
- Identifique o caso de uso.
- Escolha o protocolo mínimo.
- Defina o contrato do evento.
- Defina o schema versionado.
- Defina a estratégia de retry.
- Defina a estratégia de replay.
- Defina a política de retenção.
- Defina a estratégia de observabilidade.
- Defina a estratégia de segurança.
- Defina a estratégia de rollback.
type Channel = "sse" | "websocket" | "kafka";
function chooseChannel(input: {
browserFacing: boolean;
bidirectional: boolean;
durableReplay: boolean;
lowLatencyUI: boolean;
}): Channel {
if (input.durableReplay) return "kafka";
if (input.browserFacing && !input.bidirectional) return "sse";
if (input.browserFacing && input.bidirectional) return "websocket";
return input.lowLatencyUI ? "websocket" : "kafka";
}
realtime-checklist:
- protocol-chosen
- schema-versioned
- auth-enforced
- rate-limited
- heartbeat-configured
- retry-limited
- deduplication-ready
- replay-tested
- dlq-monitored
- lag-alerted
- observability-coupled
- rollout-canary
- rollback-proven
Scale With Intent
- Scale only after a real bottleneck appears.
- Scale partitions when one key becomes hot.
- Scale replicas when consumers lag consistently.
- Scale websocket nodes when active connections grow.
- Scale the broker when retention and throughput require it.
- Scale the frontend when rendering can no longer keep up.
- Scale the buffer when brief spikes are acceptable.
- Scale the queue when downstream systems slow down.
- Scale the worker pool when CPU is the limit.
- Scale the autoscaler only with the right metrics.
- Scale the alerting only after you know what matters.
- Scale the retry budget only when the downstream is stable.
- Scale the backoff only after you measure failure modes.
- Scale the cache only when the payload can be cached.
- Scale the TTL only when freshness tolerates it.
- Scale the fan-out only when the audience justifies it.
- Scale the retention only when replay or audit needs it.
- Scale the team only when the operational burden requires it.
- Scale the cost dashboard before the cost explodes.
- Scale the trust only with clear contracts.
Browser Delivery Patterns
- Use SSE for feed-style updates.
- Use SSE for notifications.
- Use SSE for progress bars.
- Use SSE for dashboard refresh.
- Use WebSocket for chat.
- Use WebSocket for editing.
- Use WebSocket for collaboration.
- Use WebSocket for presence.
- Use WebSocket for typing indicators.
- Use WebSocket for user commands.
- Use WebSocket for low-latency acknowledgements.
- Use WebSocket when the browser must talk back.
- Use polling only when the data changes slowly.
- Use long polling only when the infrastructure forces it.
- Use batching when the UI tolerates it.
- Use diff payloads when the state is large.
- Use reconnect with backoff.
- Use heartbeat to detect stale sockets.
- Use optimistic UI when the domain allows it.
- Use reconciliation after reconnect.
Broker Delivery Patterns
- Kafka for durable fan-out.
- Kafka for event history.
- Kafka for replay.
- Kafka for multiple consumers.
- Kafka for loose coupling.
- Kafka for analytical pipelines.
- Kafka for notification pipelines.
- Kafka for indexing pipelines.
- Kafka for audit pipelines.
- Kafka for billing pipelines.
- Kafka for ML feature pipelines.
- Kafka for enrichment pipelines.
- Kafka for cross-service workflows.
- Kafka for backfill jobs.
- Kafka for delayed processing.
- Kafka for ordered processing by key.
- Kafka for absorbing spikes.
- Kafka for decoupling write from read.
- Kafka for isolating slow consumers.
- Kafka for keeping a canonical event log.
Consumer Operations
- Consume idempotently.
- Commit offsets deliberately.
- Handle duplicate delivery.
- Handle out-of-order delivery.
- Handle missing delivery.
- Handle poison messages.
- Handle schema evolution.
- Handle replay safely.
- Handle partial failure.
- Handle consumer rebalance.
- Handle retry with limits.
- Handle queue growth.
- Handle offset reset.
- Handle dead letters.
- Handle batch boundaries.
- Handle processing timeouts.
- Handle downstream slowness.
- Handle burst traffic.
- Handle restart recovery.
- Handle deploy overlap.
Observability That Pays Off
- Measure end-to-end latency.
- Measure publish latency.
- Measure consume latency.
- Measure reconnect rate.
- Measure duplicate rate.
- Measure retry rate.
- Measure delivery failure rate.
- Measure lag by partition.
- Measure lag by consumer group.
- Measure active connection count.
- Measure payload size distribution.
- Measure throughput per channel.
- Measure error frames.
- Measure dropped frames.
- Measure heartbeat misses.
- Measure consumer restarts.
- Measure broker saturation.
- Measure render delay.
- Measure business outcome latency.
- Measure cost per million events.
Security And Abuse
- Authenticate before subscribing.
- Authorize before delivering.
- Validate every payload.
- Reject unknown message types.
- Reject oversized frames.
- Reject expired tokens.
- Reject unauthorized channels.
- Reject replay attacks.
- Reject fan-out abuse.
- Reject origin spoofing.
- Rate limit by user.
- Rate limit by IP.
- Rate limit by channel.
- Rotate credentials regularly.
- Encrypt sensitive payloads.
- Mask PII in logs.
- Audit access to critical streams.
- Isolate admin channels.
- Protect the broker network.
- Protect the reconnect path.
Failure Drills
- Simulate broker lag.
- Simulate broker loss.
- Simulate consumer crash.
- Simulate reconnect storms.
- Simulate duplicate events.
- Simulate out-of-order events.
- Simulate message bursts.
- Simulate payload spikes.
- Simulate schema drift.
- Simulate auth failures.
- Simulate token expiry.
- Simulate slow downstreams.
- Simulate dead letter growth.
- Simulate heartbeat loss.
- Simulate network partitions.
- Simulate rolling deploys.
- Simulate browser tab sleep.
- Simulate mobile backgrounding.
- Simulate cache staleness.
- Simulate rollback.
Replay And Retention
- Retention defines history.
- Replay defines recovery.
- Purge defines cost.
- Audit defines compliance.
- Snapshot defines fast restore.
- Log compaction defines state compression.
- TTL defines freshness.
- Backfill defines catch-up.
- Rehydrate defines startup.
- Checkpoint defines progress.
- Watermark defines completeness.
- Tombstone defines deletion.
- Snapshot plus log defines resilience.
- Cache plus replay defines UX.
- Index plus replay defines analytics.
- Stream plus snapshot defines bootstrap.
- Dead letter plus replay defines escape hatch.
- Migration plus replay defines evolution.
- Retention plus replay defines governance.
- Replay plus observability defines trust.
Ordering And Dedup
- Order by business key, not by accident.
- Deduplicate by stable event id.
- Keep sequence numbers when ordering matters.
- Reject conflicting updates when version drifts.
- Buffer when late arrivals are acceptable.
- Drop when stale events are harmful.
- Merge when domain rules allow it.
- Split when payload responsibility is mixed.
- Use idempotency keys for commands.
- Use causal metadata when needed.
- Preserve per-key order in the broker.
- Preserve user experience order in the client.
- Preserve audit order in storage.
- Preserve event version in schemas.
- Preserve trace correlation in logs.
- Preserve retry count in metadata.
- Preserve source system in headers.
- Preserve replay cursor in checkpoints.
- Preserve processing timestamp in metrics.
- Preserve domain meaning across channels.
Reference Implementation Notes
interface StreamState {
lastEventId: string | null;
lastSequence: number;
reconnects: number;
}
function shouldReconnect(state: StreamState) {
return state.reconnects < 5;
}
function isDuplicate(event: { id: string }, seen: Set<string>) {
return seen.has(event.id);
}
function buildMetricName(prefix: string, channel: string, name: string) {
return `${prefix}.${channel}.${name}`;
}
const metrics = [
buildMetricName("stream", "websocket", "latency"),
buildMetricName("stream", "sse", "reconnects"),
buildMetricName("stream", "kafka", "lag"),
];
Extended FAQ
- SSE is not obsolete.
- WebSocket is not always cheaper.
- Kafka is not a browser transport.
- Polling is not banned.
- Replay is not free.
- Ordering is not global by default.
- Idempotence is worth the discipline.
- Backpressure is a product feature.
- Heartbeats are operational hygiene.
- Rate limits are safety valves.
- Dead letters are not optional.
- Observability is part of the contract.
- Security is not an afterthought.
- Retention is a business choice.
- DLQ monitoring is mandatory.
- Reconnect must be tested.
- Versioning must be explicit.
- Cost must be visible.
- Latency must be measured.
- The UX tells you what matters.
Final Field Notes
- Pick the simplest channel that fits the constraint.
- Prefer SSE when the browser only listens.
- Prefer WebSocket when the browser talks back.
- Prefer Kafka when replay matters.
- Prefer polling when the data barely changes.
- Measure latency from source to screen.
- Measure lag per consumer group.
- Measure reconnect storms early.
- Measure duplicate deliveries explicitly.
- Measure payload size distribution.
- Measure the user-visible delay, not just the broker delay.
- Keep the schema versioned from day one.
- Keep the retry policy bounded.
- Keep the backpressure visible.
- Keep the DLQ monitored.
- Keep the heartbeat cheap.
- Keep the observability actionable.
- Keep the security checks close to the edge.
- Keep the rollback path boring.
- Keep the replay path tested.
- Keep the retention choice deliberate.
- Keep the ordering guarantee explicit.
- Keep the consumer idempotent.
- Keep the producer honest.
- Keep the UX simple.
- Keep the broker isolated.
- Keep the channel name semantic.
- Keep the metrics labeled.
- Keep the docs honest.
- Keep the failure drills scheduled.
- Keep the cost visible.
- Keep the contract smaller than the temptation.
- Keep the system useful under pressure.
#newshortarticle
English
Title: Realtime Streaming Architectures: Pick the Right Pipe for the Job
Summary: Realtime is not one technology. Polling, SSE, WebSockets, and Kafka solve different latency, durability, and fan-out problems. The right architecture depends on directionality, ordering, persistence, and how much operational complexity your team can support.
CTA: If every feature defaults to WebSockets, you are probably paying for complexity you do not need.
Português
Título: Arquiteturas de streaming em tempo real: escolha o canal certo
Resumo: Realtime não é uma tecnologia só. Polling, SSE, WebSockets e Kafka resolvem problemas diferentes de latência, durabilidade e fan-out. A arquitetura certa depende da direção do fluxo, da ordenação, da persistência e da complexidade operacional que seu time aguenta sustentar.
CTA: Se todo recurso começa em WebSocket, você provavelmente está comprando complexidade demais.