Figma

How Figma's multiplayer editing works

Why Figma skipped operational transformation, how a server-authoritative, CRDT-inspired model keeps everyone in sync, and the clever tricks behind reparenting, ordering, and undo.

Based on How Figma's multiplayer technology works by Evan Wallace (Figma, 16 October 2019).

9 min read · Bloom is not affiliated with Figma. Read the original for the full story.

TL;DR

  • Figma deliberately avoided operational transformation (OT): powerful, but complex and hard to get right for a small team.
  • Instead it uses a CRDT-inspired model with one twist: a central server is the final authority, which removes most of the complexity of fully decentralized CRDTs.
  • A document is just a map of object IDs to property maps, and conflicts resolve per property: the last write the server receives wins.
  • Hard cases (moving objects between parents, ordering siblings, undo) are solved with small, targeted ideas: parent pointers, fractional indexing, and a careful undo rule.

The problem

When Figma launched, no design tool offered real-time collaboration in the same file. Building it meant answering the classic question every collaborative editor faces: when two people change the same thing at the same time, what happens?

The well-known answer in 2019 was operational transformation (OT), the technique behind Google Docs. Figma's team looked at it and decided against it. As the article puts it, OT leads to a "combinatorial explosion of possible states": every pair of operation types needs a transform rule, and getting all of them right is notoriously difficult. For a startup that wanted to ship, and for a visual editor rather than a text editor, that cost wasn't justified.

The core idea: CRDT-inspired, but with a server in charge

CRDTs (conflict-free replicated data types) let replicas merge changes in any order and still converge, without a central coordinator. That decentralization is exactly what makes them heavy: extra metadata, tombstones, and careful algorithms.

Figma took the ideas of CRDTs but kept a central server as the authority. Clients send changes to the server; the server decides the final state and broadcasts it. Because one party decides, Figma doesn't need the machinery that lets peers agree without one.

The data model is deliberately simple:

Document = Map<ObjectID, Map<Property, Value>>

Every layer, frame, and shape is an object with an ID and a bag of properties (x, fill, name, parent…). A nice side effect the article highlights: adding a feature usually just means adding a new property.

Resolving conflicts, one property at a time

Conflicts are resolved per property, last writer wins: if Ana and Ben both change the same rectangle's fill at the same moment, whichever change reaches the server last is the final value. If Ana changes the fill while Ben changes the width, there's no conflict at all, since they touched different properties.

Last-writer-wins would be unacceptable for prose (you'd lose someone's sentence), but for a design tool it's a reasonable trade: two people rarely set the same property of the same object at the same instant, and when they do, either value is a valid design.

Avoiding flicker. Clients apply their own edits immediately, without waiting for the server. That creates a problem: an older server update for the same property could arrive and briefly overwrite the local value, making it flicker. Figma's rule: while a local change is unacknowledged, the client ignores incoming server values for that property. The local value is treated as the best prediction of where the document will end up.

The hard parts: creating, moving, and ordering objects

Creating objects offline. IDs combine the client's ID with a locally generated part, so clients can create objects without asking the server and IDs never collide.

Moving objects between parents. Instead of parents storing lists of children, each child stores a parent pointer as a property. Moving a layer into another frame is then just a property change, and it composes with other people's edits to that layer. A move can still create a cycle (A inside B while someone else puts B inside A). The server rejects cycle-creating updates; until the rejection arrives, the client simply hides the affected objects. That's a pragmatic answer to a rare, temporary situation.

Ordering siblings. Layer order uses fractional indexing: each child has a position that is a fraction between 0 and 1, and inserting between two siblings means picking a value between their positions (for example, averaging them). No other children need renumbering, so concurrent reorders rarely conflict. The parent pointer and position are updated together as a single property, so a move is atomic.

Servers, offline, and undo

Each document is handled by one server process, and clients connect over WebSockets. Opening a file downloads its full state. Going offline is simple: clients keep editing, and on reconnect they download the fresh state, re-apply their local changes on top, and continue syncing.

Figma also separates concerns: the multiplayer system syncs document content, while things like file metadata and permissions live in a regular database (Postgres), because they have different performance, offline, and security needs.

Undo in a shared document gets a principled rule from the article: if you undo a lot, copy something, and redo back to the present, the document shouldn't change. Undo writes to the redo history and redo writes to the undo history, so undoing never clobbers what collaborators did in the meantime.

  Client A                     Server (one process per document)                Client B
  ─────────                    ────────────────────────────────                 ─────────
  apply edit locally ──────▶   receive change ─▶ check rules (e.g. cycles)
  (pending, unacked)           decide final value: last write per property
                               broadcast  ───────────────────────────────────▶ apply update
  ◀── ack + updates ──────────
  ignore server values for props still pending locally

  Document = Map<ObjectID, Map<Property, Value>>
  child.parent = { parentId, position: fraction in (0, 1) }   // reparent + reorder in one write
Figma's multiplayer model (simplified)

Key decisions and trade-offs

DecisionWhyTrade-off
Skip OT; use a CRDT-inspired modelOT's per-operation transform rules are hard to implement correctly; a property-based model is far simpler.No character-level merging of concurrent text edits to the same property.
Make the server the authorityOne decider removes most of the complexity of decentralized CRDTs.Requires a server round trip to settle conflicts; no peer-to-peer sync.
Last-writer-wins per propertySimple and predictable; concurrent edits to the same property of the same object are rare in design work.One person's simultaneous change to that exact property is silently replaced.
Parent pointers + fractional indexingMoves and reorders become single property writes that rarely conflict.Rare temporary cycles must be detected server-side and hidden on clients.

What this means for your frontend

  • Start from your domain. Last-writer-wins per field is often good enough for structured data (design objects, task boards, forms); reserve OT or CRDTs like Yjs for rich text.
  • Model documents as flat maps of IDs to properties. Conflicts shrink to the field level, and new features become new fields.
  • Make local edits instant and suppress stale server echoes for pending fields. That one rule removes most visible flicker in optimistic UIs.
  • Store relationships on the child (a parent pointer) and order with fractional indexes; you avoid rewriting arrays and most reorder conflicts.
  • Keep collaborative document state separate from metadata and permissions, which need different guarantees.

Check your understanding

Two designers change the same rectangle at the same time: one edits its fill, the other its width. What happens in Figma's model?

Why does a Figma client ignore incoming server values for properties it changed but the server hasn't acknowledged yet?

Go deeper on Bloom

Explainer written 22 October 2026.