Grammarly·Software Engineer·Onsite - System Design / Architecture·Senior

Senior

Jul 2026

Summary

System design round at Grammarly for a software engineer role. The whole thing was one big question about building a real-time collaborative editor, Figma-style. Dense problem with a lot of moving parts.

Questions Asked (1)

Design the backend and key client interactions for a real-time collaborative design editor, similar to Figma, supporting concurrent edits, presence, and persistence across network failures.

System DesignTechnical Trade-offsData Modeling

Author's notes

This one ate up the entire session.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a high-level architecture that separates real-time collaboration (WebSocket-based) from persistence (CRDT/OT with durable storage). Walk through data modeling, conflict resolution, presence, and failure recovery, explicitly discussing trade-offs between consistency, latency, and complexity.

Pro tip: Anchor your design around a CRDT-based document model with a central relay server for ordering, and explicitly address how you'd handle offline edits and reconnection—this shows you understand real-world collaboration challenges beyond the happy path.

1. Clarify Requirements and Scale

Ask about expected number of concurrent users per document, document size, latency requirements, and consistency needs (e.g., strong vs eventual). This scopes the problem and shows you prioritize.

2. High-Level Architecture

Propose a client-server model with WebSocket connections for real-time updates, a central coordination service for ordering and broadcasting, and a persistence layer (e.g., database + object storage) for durability.

3. Data Model and Conflict Resolution

Choose a CRDT or OT approach for merging concurrent edits. Describe the document representation (e.g., tree of nodes with unique IDs) and how operations are applied and transformed.

4. Presence and Awareness

Design a lightweight presence system using ephemeral messages (e.g., cursor positions, selections) that are broadcast but not persisted, with throttling and conflict-free merging.

5. Fault Tolerance and Persistence

Explain how clients buffer operations during disconnection, resync on reconnect (e.g., via operation log or state vector), and how the server persists snapshots and operation logs for recovery.

Key Points to Mention

CRDT vs OT trade-offs: CRDTs offer offline support and eventual consistency but may have higher metadata overhead; OT requires a central server for transformation but can be more efficient.
WebSocket for real-time bidirectional communication, with fallback to long-polling; use of heartbeats and reconnection logic.
Document model: use of unique IDs for elements, immutable operations, and a tree structure to support fine-grained edits.
Presence: use of a separate ephemeral channel, throttling updates, and conflict-free merging (e.g., last-write-wins per user).
Persistence: write-ahead log or operation log for durability, periodic snapshots to reduce replay time, and use of a database like PostgreSQL or a distributed store like Cassandra.
Network failure handling: client-side operation queue, exponential backoff for reconnection, and server-side session resumption with state vectors.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.