Pivot

Overview

Pivot brings a team's conversations, meetings, and visual thinking into a single real-time workspace. The hard part isn't any one feature — it's making chat, video, and a shared whiteboard all stay perfectly in sync for everyone at once, without lag and without edits colliding. We architected and built the platform end to end to make that feel effortless.

The challenge

Teams needed to chat, meet over video, and sketch on shared whiteboards together — without lag and without edits colliding. Real-time collaboration is deceptively hard: presence, message ordering, and conflict-free editing all have to stay consistent across many concurrent users at once.

• Keep every participant's view consistent in real time, even under network jitter.
• Merge simultaneous whiteboard edits from multiple people without overwrites or lost work.
• Sustain low-latency messaging and presence as concurrent sessions grow.
• Deliver live video and audio reliably alongside the collaboration layer.
• Ship a unified UX where chat, calls, and whiteboards feel like one product — not three glued together.

The solution

We built a real-time platform on high-performance backend services, with live video and a whiteboard whose edits merge automatically no matter who is typing or drawing. The architecture keeps everyone's view consistent in real time while staying responsive under load.

Rather than bolting features onto a chat app, we designed Pivot around a shared session model: every room has a single source of truth for presence, messages, and document state. Backend services in Go and Rust handle the hot paths — message routing, presence fan-out, and CRDT merge logic — while the React client renders a cohesive workspace that switches between chat, video, and whiteboard without losing context.

What we delivered

• ✓Real-time chat with ordered, reliable message delivery.
• ✓WebRTC-based video and audio meetings.
• ✓Shared whiteboard with conflict-free (CRDT-style) collaborative editing.
• ✓Live presence and typing indicators across sessions.
• ✓Cross-platform clients with consistent real-time behaviour.
• ✓Production deployment pipeline with monitoring and CI/CD.

Architecture

• High-performance backend services in Go and Rust for low-latency messaging and presence.
• WebRTC-based video and audio for live meetings.
• Conflict-free (CRDT-style) sync so simultaneous edits on shared whiteboards merge without overwrites.
• Presence and pub/sub layer that scales to many concurrent sessions.
• PostgreSQL for durable state; Redis for pub/sub, caching, and session coordination.
• React front end with optimistic updates and reconnect handling for flaky networks.

Key engineering decisions

• Split hot-path services (Go/Rust) from the web client so latency-sensitive logic never blocks on UI concerns.
• Chose CRDT-style merge for whiteboard edits instead of last-write-wins — eliminates the most common real-time collaboration bug class.
• WebRTC for video rather than a third-party embed — full control over call lifecycle and in-app UX.
• Designed rooms as the unit of consistency so chat, video, and whiteboard share one presence and permission model.

Tech stack

Engagement

Ongoing product partnership — architecture, build, and scale.

Team: 2–4 senior engineers

Results

Pivot is in production across 3 universities and 10+ teams — serving thousands of students and members who chat, meet, and collaborate on shared whiteboards in real time, on an architecture built to scale with usage rather than be rewritten.

Lessons learned

• 1Real-time UX is won or lost in reconnect and offline handling — users notice stale state more than occasional latency spikes.
• 2CRDT merge logic belongs on the server with client-side optimistic rendering; debugging merge conflicts purely client-side does not scale.
• 3Presence is deceptively expensive at scale — fan-out architecture and sensible debouncing matter early, not after launch.