Relaydesk

We started with server-sent events because the traffic is overwhelmingly server-to-client. That held until typing indicators and presence heartbeats made the client chatty, at which point maintaining a separate POST path for every upstream signal was more code than just opening a socket. We moved to plain WebSocket — no framework — with a hand-rolled heartbeat.

Every mutation writes to Postgres and appends to a per-conversation Redis stream with a monotonic id. Clients track the last id they processed. On reconnect they send it back and get the gap replayed rather than refetching the world — so a thirty-second tunnel outage costs a few kilobytes instead of a full resync.

socket.addEventListener('open', () => {
  // resume from the last event we durably applied, not from "now"
  socket.send(JSON.stringify({ type: 'resume', since: store.lastEventId }));
});

socket.addEventListener('message', (e) => {
  const msg = JSON.parse(e.data);

  // a gap means we missed something: fall back to a full refetch
  if (store.lastEventId && msg.prevId !== store.lastEventId) {
    return resyncConversation(msg.conversationId);
  }

  apply(msg);
  store.lastEventId = msg.id;
});

Presence lives entirely in Redis with a short TTL, refreshed by heartbeat. Nothing about it is durable and nothing needs to be — if Redis restarts, every agent reappears within one heartbeat interval. Trying to persist presence to Postgres was the first thing we built and the first thing we deleted.

• Key per agent, 30s TTL, refreshed every 10s. Expiry is the disconnect signal.
• Draft indicators are throttled to one event per 800ms per agent — a keystroke-rate firehose helps nobody.
• Locks are advisory. A colliding reply warns rather than blocks; agents route around it socially.