Figma Interview Questions & Process for Software Engineers

The Figma loop keeps returning to what a full design editor in a browser tab takes: algorithms as editor problems, and system design for many people on one canvas.

20 lessonsbuilt from 17 candidate reports

Figma
Alex Chen
Updated

01How the Figma interview process works

Silence costs you here even when you land on the right answer. Figma's interviewers pair with you rather than watch you: they will argue about a variable name or drop an edge case in halfway through, and how you absorb that goes into the write-up next to whether the code ran. Someone who narrates a slower path and lets the interviewer into it usually scores above someone who reaches the optimal answer without saying much. The loop around all of that is ordinary enough: a recruiter screen, a technical phone screen with a working coding problem, then a virtual onsite that mixes coding, system design, and behavioral rounds.

After the onsite the panel files written feedback, and one debrief settles the hire and the level together before anything moves to the offer, which is why a yes you are happy with and a level you are not can arrive in the same call. The hiring manager holds final authority when the room does not converge. That makes the whole thing feel less like clearing a company-wide bar and more like being hired by one particular team.

1
Application
2
Recruiter
3
Screen
Phone
4
Onsite
4–5 rounds
5
Debrief
6
Offer
Read the full process breakdown

02The Figma onsite loop

The onsite is one block that runs coding, system design shaped by Figma's own product, and a behavioral hour about how you work and how much you care about what you ship. The split moves with level, team, and track: the frontend and rendering loops trade part of the distributed-systems conversation for the browser paint path, and they go deeper than most companies' frontend rounds do.

The behavioral hour usually turns into a walk through a project you owned, and the questions keep landing on why rather than what. Answers that carry numbers hold up: the latency before and after, the share of a machine you handed back. Generic ownership language gets pushed on until it either produces a specific or falls over.

CodingAlgorithms
Medium-centered algorithmic problems where clean, working code and clear communication matter as much as the optimal answer, spanning arrays and hashing, trees and graphs, dynamic programming, and intervals
System designProduct
Collaboration-shaped design questions drawn from what Figma actually builds: real-time multiplayer editing, live presence and cursors, the canvas rendering path, file storage and version history, and comments
Behavioral & craftValues
A conversation about how you work, how you handle ambiguity, and how much you care about the details of what you ship, grounded in genuine interest in Figma and its products
Read the full loop breakdown

03The Figma coding bar

The algorithms themselves are ordinary and sit around medium: arrays, strings and hashing, hash-map and data-structure design, trees and graphs, dynamic programming, and heaps and intervals. They are just rarely posed as themselves. Implement undo and redo over a document model, merge the styled ranges inside a block of text, walk a layer tree. The algorithm underneath is one you have seen before, and the interviewer is watching how you model the thing sitting on top of it.

The code runs in this round, so the tests pass or they do not, and passing them is where the evaluation starts rather than where it ends. State the invariant before anyone asks for it, which on an undo problem means saying out loud that a fresh edit clears the redo stack, and give the complexity without being prompted. A readable solution you can defend under a follow-up beats a clever one you cannot explain, because the follow-up is coming.

Coding roundtarget allocation
Clarify
Pick the pattern, code it out loud
Test edges
Recognize the shapeCore algorithmEdge cases
Read the full coding breakdown

04Figma system design

The anchor problem is real-time multiplayer editing, and the prep answer everyone brings to it is CRDTs and operational transforms. Figma looked at both and shipped neither, and it published the reasoning: operational transforms carried more complexity than the problem needed, and a true CRDT carries coordination overhead built for peer-to-peer systems that a central server makes unnecessary. What runs instead is one authoritative server process per document holding the latest value any client has sent for a given property, with the last write winning at that property boundary. Reciting the textbook comparison here puts you on the wrong side of a decision the company already made in public.

From there the round branches. Live presence and cursors looks like the same problem and is not, because a cursor position is disposable and an edit is not, and the answer that scores treats them as two channels with two different guarantees. The canvas rendering path comes with a sixteen-millisecond frame budget and an engine written in C++ and compiled to WebAssembly. File storage and version history becomes a question about snapshots against operation logs, and comments with their notifications sit outside document sync altogether, in relational storage, on a consistency story of their own.

Graders are after the reasoning more than a particular diagram. Naming the consistency model you picked, saying what breaks when a partition heals or when two hundred cursors land on one file, and tying it back to what a real user feels will carry a round further than an architecture that is technically fine and drawn in silence.

Read the full system design breakdown

05Figma levels and offer

An offer is base salary, equity, and sometimes a sign-on, and since the 2025 listing the equity is ordinary public-company RSUs on a four-year schedule, a quarter at the one-year cliff and monthly after that. The grant is written as a dollar figure and converted into shares at the price on the day it is cut, so the number in the letter and the number in your account start drifting apart the moment you sign.

That is a good reason to give base more attention than it usually gets. Equity holds the real upside and all of the volatility at the same time, and a stock that has been above $140 and below $20 since it listed makes that component a moving target rather than a promise. Treating the whole package as one number is the only way to compare it against anything else on your desk.

LevelMaps toAvg total comp (US)
L1Entry$213K
L2Software Engineer$311K
L3Senior$453K
L4Staff$697K

Average total compensation by level, per Levels.fyi (US, as of Aug 2026); self-reported and rounded. Figma labels these levels by number only; the Entry, Senior, and Staff mappings are the market-standard reading by years of experience. Since the 2025 listing the equity is public RSUs shown at an annualized value. The overall median is about $430K, and L5 reports near $733K on a thin sample.

The conversation belongs after the decision comes back positive and while the offer is still being written. A competing offer moves more than anything else you can put on the table. Without one, the lever is the level: hire and level were settled in the same debrief, so a clear case for your scope is a case about the whole band. Asking where the top of that band sits costs nothing and gets skipped constantly.

Read the full offer & negotiation guide

06What Figma actually asks

The coding side keeps returning to the same theme families: arrays, strings and hashing, hash-map and data-structure design, trees and graphs, dynamic programming, and heaps and intervals. Dynamic programming is the rarest of them and the one candidates over-prepare, while design-and-implement problems over a document or a layer tree turn up far more often than a generic prep list would suggest.

The questions that recur most
  • Design and implement a layer treedesign + implement · #1
  • LRU Cachehash-map design
  • Flatten a nested document structuretrees / design
  • Two Sumarrays / hashing
  • Group Anagramshashing
  • Longest Substring Without Repeatingsliding window
  • Merge Intervalsintervals
  • a Premium question
  • Number of Islandsgraphs / grids
  • Clone Graphgraphs
  • Course Scheduletopological sort
  • Binary Tree Level Order Traversaltrees
  • a Premium question
  • Top K Frequent Elementsheaps
  • Design real-time cursor presencecollaboration design
  • Design an in-memory key-value storedesign
Recurring coding themes
What the loop keeps coming back to
01
Arrays, strings & hashing
Two-pointer, sliding window, frequency maps
02
Hash maps & data-structure design
LRU cache, design problems, O(1) lookups
03
Trees & graphs
Traversal, BFS/DFS, topological order
04
Dynamic programming
Grid DP, subsequences, knapsack shapes
05
Heaps & intervals
Top-K, merge intervals, scheduling
06
System design
Multiplayer editing, presence, rendering, history
The behavioral questions Figma repeats
Grouped by the theme each one reads against
  • Why do you want to work at Figma?Why Figma · mission
  • Tell me about a project whose outcome depended on people outside your teamMultiplayer default
  • Tell me about a time you shared unfinished work early, and it changed the outcomeCommunicate early
  • A time a technical constraint collided with a design requirementDesign vs engineering
  • Tell me about something you built whose quality you are proud ofCraft
  • A time you changed a decision because of what it meant for the userCustomer empathy
  • Tell me about hard feedback you received, and what you did with itFeedback
  • Walk me through a project you owned end to endOwnership · deep-dive

The full bank of Figma behavioral interview questions walks all seven themes and the values each one scores, or start with the STAR method.

Each of these Figma system design interview questions is a different shape, worked end to end in the guide.

Every problem in the loop is set somewhere inside the product. System design stays there on purpose: real-time multiplayer editing, live presence and cursors, the canvas rendering path, file storage with version history, and comments. The coding keeps to the core algorithm families but poses them as editor work, and the write-up afterwards has room for how you got there as well as where you ended up...

Continue reading

The full breakdown. Every round and every pattern, with the strategy that goes with each.

Go to the Full Guide
Common questions

What are the stages of the Figma interview process?

The Figma interview runs through 6 stages: Application, Recruiter, Screen, Onsite, Debrief, and Offer.

How many rounds does the Figma interview have?

The interviewing rounds sit in the onsite (4–5 rounds). The other stages (application, recruiter, and team match) are conversations, not scored rounds.

Is the Figma interview hard?

The coding sits at medium, where clean working code and clear communication matter as much as the optimal answer. The harder, more distinctive part is the collaboration system design round drawn from what Figma actually builds, plus design-and-implement problems over a document or a layer tree that a generic prep list underweights.

Does Figma ask LeetCode questions?

Yes, medium-centered: arrays and hashing, hash-map and data-structure design, trees and graphs, dynamic programming, and heaps and intervals. Dynamic programming is the rarest of them and the one candidates over-prepare, while design-and-implement problems over a document or a layer tree turn up far more often than a generic prep list would suggest.

What is the Figma system design round?

Collaboration-shaped and drawn from the product: real-time multiplayer editing, live presence and cursors, the canvas rendering path (a 16ms frame budget on a C++ engine compiled to WebAssembly), file storage and version history, and comments. The anchor is multiplayer editing, and graders want the reasoning more than a diagram, so name your consistency model and say what breaks when a partition heals or two hundred cursors land on one file.

How does Figma handle multiplayer and CRDTs in the interview?

Do not reach for CRDTs or operational transforms as the answer. Figma evaluated both and shipped neither, and published why: OT carried more complexity than the problem needed, and a true CRDT carries coordination overhead built for peer-to-peer systems that a central server makes unnecessary. What runs is one authoritative server process per document holding the latest value per property, with the last write winning at that boundary. Presence and cursors are a separate channel, since a cursor is disposable and an edit is not.

How does Figma equity work since the IPO?

Since the 2025 listing the equity is ordinary public-company RSUs on a four-year schedule, a quarter at the one-year cliff and monthly after that. The grant is written as a dollar figure and converted to shares at the price on the day it is cut, and the stock has traded above $140 and below $20 since it listed, so give base more attention than usual and value the whole package as one number.

How long does the Figma interview process take?

Roughly four to six weeks: a recruiter screen, a technical screen, then a virtual onsite of coding, the collaboration system design round, and a behavioral-and-craft conversation, followed by a debrief. Hire and level are settled in the same debrief, so a clear case for your scope during the loop is a case about the whole band.

What are Figma levels, and how much does it pay?

Figma labels its ladder by number, L1 through L7, with no titles on Levels.fyi; by years of experience they read as Entry (L1), Software Engineer (L2), Senior (L3), and Staff (L4). Per Levels.fyi the US averages run about $213K at L1, $311K at L2, $453K at Senior, and $697K at Staff, with L5 near $733K on a thin sample, and the overall median around $430K. Since the 2025 IPO the equity is public RSUs, and the stock has been volatile, so value the whole package as one number.

Is it hard to get hired at Figma?

The coding bar is medium, where clean working code and clear communication count as much as the optimal answer, so the harder filter is the collaboration system design round drawn from Figma's product: real-time multiplayer editing, presence and cursors, the canvas rendering path. There is no published acceptance rate; reaching for CRDTs or operational transforms as the answer, when Figma evaluated both and shipped neither, is a common miss.

What are the most common Figma interview questions?

Medium coding: arrays and hashing, hash-map and data-structure design, trees and graphs, dynamic programming (the rarest of them), and heaps and intervals. The signature round is collaboration-shaped system design from the product itself: real-time multiplayer editing, live presence and cursors, the canvas rendering path on a 16ms frame budget, and file storage.