PulseRoom

Real-time multiplayer incident war-room with 60 FPS topology cursors, shared log evidence pinning, and two-engineer quorum remediation cards that heal outages live.

Comment

Inspiration

During a production outage, debugging usually fragments across isolated screens: one engineer tails logs in a terminal, another checks dashboards, people paste cropped screenshots into chat, and someone runs a risky mitigation command without a second pair of eyes. While building together in trmi, we noticed how much safer and faster development felt when our team shared one room, talked on the built-in voice call, and approved high-risk changes via vote cards. We decided to bring that exact multiplayer workflow to live production incident response.

What it does

PulseRoom turns outage triage and architecture debugging into a shared, real-time multiplayer war-room:

  • 60 FPS Multiplayer Topology Canvas & Cursor Bubbles (/): Responders join a shared room (?room=WAR-ROOM-01), see every teammate's live cursor, active tool (Inspect, Trace, Patch), and floating cursor speech bubbles (/ hotkey). Dragging any microservice node updates its layout across all connected browsers in real time.
  • Shared Root-Cause Evidence Pinning: Clicking any service node filters the distributed log stream. When a responder pins a suspicious log line (such as 142 backend processes idle in transaction on webhook-worker), it immediately lands on the shared Evidence Board with their name and timestamp.
  • Quorum-Gated Remediation Cards (Two-Key Turn): Risky infrastructure fixes are modeled as shared approval cards across three tiers (ROUTINE requiring 1 approval, BREAKING and DECISION requiring a 2-engineer quorum). Once the second responder approves a breaking card, PulseRoom executes the fix against the topology engine, draining retry storms, dropping error rates from 64.0% to 0.2%, and turning packet flow back to healthy green.
  • Playable Outage Scenarios & Autonomous SRE Peer (Maya): Includes three production outage scenarios (INC-4021 Postgres Connection Pool Exhaustion, INC-4088 Flash Sale Cache Stampede, and INC-4104 Split-Brain JWT Key Rotation), a one-click +2nd Engineer Window launcher for split-screen testing, and an autonomous SRE teammate (Maya) who inspects degraded nodes, pins evidence, and casts quorum votes.
  • One-Click Collaborative Post-Mortem: Compiles a complete Markdown post-mortem report recording MTTR, responders present, pinned evidence, quorum-approved commands, and the full audit timeline.

How we built it

We built PulseRoom as a zero-dependency Node.js RFC 6455 WebSocket server (server.mjs) and Cloudflare Worker (worker.mjs) sharing a deterministic graph telemetry engine (src/engine.mjs, src/scenarios.mjs) and an HTML5 Canvas front-end (src/ui.mjs).

We coordinated our work inside trmi (@bck-stack and @talhacomak) connected in the shared voice call and parallel lanes (cursor-shortcuts-doc in PR #1 and quorum-metrics-do in PR #2). Using trmi's SAFE EDIT approval cards, we documented our architectural decisions and edge cases directly in .termi/decisions.md and .termi/gotchas.md while testing the live Worker deployment side by side.

Challenges we ran into

  1. Separating 22 Hz Ephemeral Cursor Frames from Causal Room State (stateVersion): Broadcasting cursor movement 22 times per second while two engineers simultaneously click Approve on a remediation card caused unnecessary DOM re-renders when everything shared a single state counter. We split the protocol so cursor frames update only the 60 FPS canvas and presence bar, while causal room mutations (VOTE_CARD, PIN_LOG, MOVE_NODE, PROPOSE_CARD) increment stateVersion and trigger ordered DOM updates.
  2. Viewport-Normalized Topology Coordinates: Testing between different laptop DPI scales (125% vs 100%) initially clipped rightmost topology nodes (Redis Cluster and Postgres Primary). We implemented an automatic world-to-viewport transform (getCanvasTransform and screenToWorld) that normalizes cursor coordinates to a 1040x560 world space so all 7 microservice nodes fit cleanly on any screen size.

Accomplishments that we're proud of

  • Designing a multiplayer state engine where applying a remediation card actually recomputes upstream/downstream packet flow, p99 latency, and error rates in real time across every connected responder's screen.
  • Shipping both a zero-dependency local RFC 6455 WebSocket server and a live Cloudflare Worker deployment so anyone can test multi-window quorum voting in one click with zero login friction.

What we learned

  • Working inside trmi with parallel lanes and explicit .termi/decisions.md and .termi/gotchas.md files prevented merge conflicts when one of us tuned the scenario engine while the other adjusted canvas DPI scaling.
  • High-frequency presence telemetry (cursors, drag positions) and strict consensus actions (quorum votes) should never share the same state-versioning loop.

What's next for PulseRoom

Adding live OpenTelemetry OTLP log ingestion, Prometheus PromQL metric bindings for real Kubernetes clusters, and voice-to-cursor transcription inside the war-room canvas.

Share this project:

Updates

Submission history