Implement a Figma document with layers and properties: define the class, constructors, and methods to initialize layers, apply a property update to a layer by ID, query a layer by ID, and undo the last operation.

The key insight is this is the Command pattern applied to a mutable document tree: each operation is an object that knows how to apply itself and compute its inverse. Represent the document as a hash map of layer ID to properties, and a stack of inverse operations for undo. Apply mutates the map and pushes the inverse; undo pops and re-applies. Time is O(1) per apply/query and O(depth) for undo. Likely follow-up: extend to redo, then batch commits (beginBatch/commitBatch). Object-oriented design instincts, clean separation of state and operations, comfort with the Command pattern, and whether the candidate proactively asks about undo depth and concurrent-edit edge cases.

Design a document-editing layer that supports applying edits and undo. Implement apply(Operation op), undo(), and getText(). Then extend to transactional batching with beginBatch() and commitBatch() so a batch undoes atomically.

Model operations as objects with an inverse. A single-level undo is a stack of inverse ops; batching wraps a sequence in a compound op whose undo re-applies all inverses in reverse order. Compression (part 3) collapses a batch into one replace patch over the affected range. Part 4 adds a redo stack that clears on any new apply. The critical complexity point is O(1) getText after each op by maintaining the string incrementally rather than replaying from scratch. Follow-ups probe cursor bookkeeping and overlapping range edits. Whether the candidate handles the redo-invalidation contract correctly (any new apply clears the redo stack), and whether they think about memory cost of deep undo history.

Reading Order: implement a function that takes a list of 2D canvas objects (each with x, y, width, height) and returns them sorted in reading order — left to right, top to bottom. In Reading Order II, objects may be slightly misaligned vertically; group them into rows first, then sort within each row.

Part I: sort by y then x — O(n log n). Part II requires row-grouping with a tolerance threshold: sweep by y, use a running max-y to detect row breaks, assign row IDs, then sort by (row, x). The hard question is choosing the right tolerance (often interviewer-specified). Follow-up: what if objects overlap vertically across rows? Edge case: single-pixel objects and zero-width layers. Handling of the ambiguous tolerance parameter and whether the candidate asks for it rather than hardcoding. Also: does the sort remain stable within a row?

Design the backend for live cursors in a collaborative document editor like Figma: multiple users on the same document should see each other's cursor positions in near real-time.

Start with the data model: cursor state is (userId, documentId, x, y, timestamp). Clients send cursor events over a persistent WebSocket connection to a presence server. That server fans out to all other sessions on the same document — a pub/sub channel per document (Redis Pub/Sub or a similar broker). Key tradeoffs: cursor updates are ephemeral and lossy-tolerant, so you drop rather than queue on backpressure. Discuss client-side interpolation to smooth jitter. Scaling: stateless WebSocket servers behind a load balancer with sticky sessions or a shared broker. Follow-up: 1M concurrent users sharing 200-cursor documents — now discuss horizontal sharding of presence by documentId and cursor storm mitigation via client-side throttling. Whether the candidate distinguishes presence (ephemeral, lossy OK) from document state (durable, consistency required). Interviewers flag candidates who over-engineer with strong consistency for cursor positions.

Design conflict resolution for simultaneous text edits in a multiplayer document: two users edit the same paragraph at the same time — how do you merge their changes without data loss or divergence?

Present the OT vs CRDT choice upfront: OT (Operational Transformation) requires a central server to serialize operations; CRDTs (e.g., RGA or LSEQ for ordered text) are peer-to-peer and commutative. Figma uses CRDTs. Walk through RGA: each character has a unique ID (userId + lamport timestamp); inserts are anchored to the preceding character's ID so concurrent inserts at the same position are deterministically ordered. Deletes are tombstones. Follow-up: how do you handle offline edits that need to merge after 30 minutes of disconnection? Answer: the CRDT merge is the same — replay buffered ops against the current state. Mention snapshot + delta compression for reconnect efficiency. Concrete knowledge of at least one CRDT type (not just the name). Candidates who only say 'use CRDT' without being able to sketch the ID scheme or explain why it's commutative are flagged.

Design a poll system inside Figma: designers can embed a poll widget in a document; viewers respond; the creator sees live results with many concurrent respondents.

Data model: poll (id, creatorId, documentId, question, options[]); response (pollId, userId, optionId, timestamp). Write path: HTTP POST to a poll-responses service, which writes to a database and publishes to a results-aggregation topic. Read path for live results: WebSocket or SSE from a results-fanout service subscribed to the topic; sends incremental deltas. Aggregation: maintain a running tally in Redis per pollId (HINCRBY) for O(1) updates; back-fill from DB on cold start. Concurrency edge case: duplicate votes — idempotency key on (pollId, userId). Scale: poll results are eventually consistent and a slight lag is acceptable, so async aggregation is fine. Follow-up: support for ranked-choice voting or vote changes. Clear separation of the write path (durability) from the read path (low-latency fanout). Candidates who skip the real-time delivery mechanism and only describe a polling endpoint miss Figma's product context.

Why do you want to work at Figma? What specifically about the product or mission draws you here?

Figma screens hard for genuine product affinity in the recruiter call — candidates who have never seriously used Figma as a tool tend to struggle throughout the loop. A strong answer ties personal usage or a specific engineering problem (WebGL rendering, CRDT-based collaboration, plugin APIs) to what excites you about building it. Mention something you would want to improve, which signals you have thought about the product critically rather than just rehearsed a company mission statement. Authentic product familiarity vs. generic 'I love design tools' answers. Figma recruiters ask follow-up questions about specific features to probe depth.

Tell me about a time you had to balance a technical constraint against a design requirement and the two were in direct tension. What did you decide, and what would you do differently?

Use STAR with emphasis on the tradeoff reasoning: what were the exact constraints, who had stake in each side, what did you measure or prototype to resolve the ambiguity? Figma expects engineers to be design-literate and to have collaborated with designers rather than simply overriding or accepting specs. Concrete metrics strengthen the answer (e.g., 'the design required 60fps on a 2-year-old iPad, which ruled out SVG and pushed us to Canvas'). The 'what would you do differently' probe tests self-awareness. Whether the engineer treats design as a constraint to negotiate with rather than a requirement to blindly implement or casually override. Vague answers about 'balancing priorities' without specific tradeoff logic are a red flag.

Describe a project where you owned a significant technical decision from proposal through production. Walk me through the tradeoffs you weighed, who disagreed with you, and how you built alignment.

This is the project deep-dive round framed as a behavioral question. Prepare a slide deck or structured narrative: scope, options considered with explicit pros/cons, your recommendation and reasoning, who pushed back and why, how you resolved it (data, prototype, or consensus process), and the outcome with measured results. Concrete numbers are expected: latency improvement, error-rate reduction, scale achieved. Follow-up questions will probe why you did not choose the alternative you rejected. Evidence of genuine ownership (not 'we decided' but 'I proposed and defended'). Interviewers verify technical depth by asking about the rejected alternatives — candidates who cannot defend the road not taken have likely borrowed the story.

Figma Interview Questions

Figma's SWE loop runs roughly 4 to 6 weeks and consists of a recruiter screen, a hiring manager call (30 min), a 1-hour technical phone screen on CoderPad, a full onsite block of 5 rounds (2 coding, 1 system design, 1 behavioral, 1 project deep-dive), and an executive screen with the director. Questions are deliberately "Figma-flavored" — standard algorithms dressed in canvas, layer-tree, or collaboration context — rather than pure LeetCode. The bar has tightened since the 2023 Adobe acquisition collapse; hiring resumed in 2024 with the same loop intact, and candidates report the executive screen intensifies areas flagged as weak in the onsite.

20 real questions across 3 rounds

Reported via LeetCode Figma company tag (interviewsolver.com lists 41 problems), Glassdoor first-hand report (Jan 2024, QTN_6908979: 'Implement a figma doc with layers, properties, class definitions and methods to update'), interviewing.io Figma page (two confirmed Figma-flavored prompts), GreatFrontEnd Figma interview guide (citing recent candidate reports for Reading Order and Styled Text Ranges), prachub.com (confirmed Figma screen: document editor with undo/redo and batching), linkjob.ai first-hand write-up dated August 2025, techprep.app Figma process guide (Merge Intervals, Undo Redo System).

Run a Figma mock with the AI interviewer. It asks questions like these, follows up on your answers, and tells you exactly what to fix. The only score that means anything is the one on your real answers.

Continue with Google

Keep prepping

All company interviews