1 Não tratar reconexão e estados de conexão

WebSocket não é “só abrir e pronto”. Em rede real, o link cai, proxies reiniciam e firewalls reavaliam rotas.
Se você não modela os estados (conectando, aberto, fechando, fechado), seu cliente vira um gerador de erros.

2 Falta de heartbeat (ping/pong) e timeouts

Muita gente confia apenas no “fechou” do WebSocket. Só que, na prática, você pode ficar com uma conexão
“zumbi”: o TCP caiu, mas o endpoint não detectou imediatamente. Resultado: mensagens nunca chegam e o app fica
acreditando que está online.

• Não usar ping/pong (ou equivalente no seu stack).
• Timeout inexistente ou muito alto, atrasando detecção de falhas.
• Heartbeat rodando em intervalos fixos sem considerar concorrência e carga.

3 Protocolos e mensagens sem contrato (schema)

WebSockets entregam bytes. Se você não cria um contrato claro para as mensagens, o sistema tende a virar um
“mix de tipos” impossível de evoluir com segurança.

Exemplo de contrato e parsing defensivo

// Estruture mensagens com um contrato explícito.
// (Exemplo em TypeScript/JavaScript)

const PROTOCOL_VERSION = 1;

function safeParseMessage(raw) {
  let msg;
  try {
    msg = JSON.parse(raw);
  } catch {
    return { ok: false, error: "invalid_json" };
  }

  if (!msg || typeof msg !== "object") return { ok: false, error: "invalid_shape" };
  if (msg.version !== PROTOCOL_VERSION) return { ok: false, error: "unsupported_version" };
  if (typeof msg.type !== "string") return { ok: false, error: "missing_type" };
  if (!("payload" in msg)) return { ok: false, error: "missing_payload" };
  if (typeof msg.id !== "string" && typeof msg.id !== "number") return { ok: false, error: "missing_id" };

  return { ok: true, msg };
}

// Exemplo de uso:
socket.addEventListener("message", (event) => {
  const result = safeParseMessage(event.data);
  if (!result.ok) {
    // Fechar conexão ou apenas registrar, dependendo do caso.
    // O importante é não processar estado com dados inválidos.
    console.warn("Mensagem rejeitada:", result.error);
    return;
  }

  const { type, payload, id } = result.msg;

  switch (type) {
    case "order.updated":
      // Aqui você sabe o contrato e pode validar payload por tipo.
      handleOrderUpdated(payload, id);
      break;

    case "pong":
      // Atualize o timestamp do heartbeat.
      onPong(id);
      break;

    default:
      console.warn("Tipo de mensagem desconhecido:", type);
  }
});

4 Escalonamento: falta de backpressure, ordenação e deduplicação

WebSocket te dá um canal contínuo. Se você produz mensagens mais rápido do que o destinatário consome,
vai acumulando fila, aumentando latência e eventualmente derrubando o serviço.