Figma CoderPad Interview: The Undo/Redo Layer Problem in 60 Minutes

Figma CoderPad interview: the reported 60-minute layer store problem, undo, redo and batch follow-ups, a TypeScript sketch, a time plan and red flags.

By OphyAI Team • • Updated October 26, 2026 • 1523 words

Last updated: October 2026

Quick Answer

The Figma CoderPad interview is a reported 60-minute live coding screen built around a small piece of a design editor, most often a document of layers with properties that you must set, undo, redo and group into batches. Figma has not published the format, so confirm it with your recruiter. Rehearse the layer problem end to end in OphyAI Coding Interview and the narration in OphyAI Interview Practice.

PartDetail
LengthAbout 60 minutes (prep guides)
ToolCoderPad: editor on the left, run output on the right
Core promptLayer store with get, set, undo (reported)
Follow-upsRedo, batched edits, memory limits, tree order (reported)
Posted US base pay$153,000-$376,000 for Software Engineer roles (Greenhouse, October 2026)

What Figma Is Testing in This Round

Figma is testing whether you can turn a vague editor feature into working, correct code while talking. The Figma interview guide covers the full loop; this page goes deep on the screen.

What they evaluate (per prep guides):

  • Clear history rules before code. PracHub advises writing them out first: “a new edit clears the redo stack, and a batch undoes as one unit.”
  • Your own data structure. A history of deltas you built, not a library.
  • Edge cases traced by hand: empty document, one layer, undo with nothing to undo.
  • Adaptability. Your first version is “the start of the discussion,” and follow-ups tighten memory or add redo.

Red flags:

  • Snapshotting the whole document on every edit.
  • Redo that survives a new edit.
  • A batch that undoes one property at a time.
  • Silent coding, then a long debug at minute 50.

What to Expect

Format. CleverPrep (August 2026) describes a 60-minute CoderPad screen with “Figma-flavored” problems at LeetCode medium difficulty. GreatFrontEnd says questions “often look like small pieces of a design editor,” and one candidate described “a TypeScript class for managing document properties with apply, undo, and batching.” techinterview.org lists TypeScript, Python or Rust depending on role.

Environment. CoderPad’s candidate guide says you write on the left, press Run and read output on the right; autocomplete exists for many languages. AI Assist only appears if the interviewer turns it on per pad, and CoderPad saves “all pad users’ prompts and AI output” for playback.

Camera. Figma’s engineering postings require candidates to keep cameras on during video interviews.

Example Questions and How to Answer Them

These are reported or illustrative prompts, not confirmed Figma questions.

1. “Store layers with properties; support get, set and undo.”

Approach: Record a small change per edit (layer ID, key, old value, new value), never a full copy. Undo writes the old value back, and deletes the key if it did not exist before.

2. “Add redo, then add batches.”

Approach: Keep two stacks of change lists. A new commit clears redo. A batch is one entry: undo replays it in reverse, so repeated writes to the same key restore the original value.

type Change = { id: string; key: string; before: unknown; after: unknown };

class LayerDoc {
  private layers = new Map<string, Record<string, unknown>>();
  private undoStack: Change[][] = [];
  private redoStack: Change[][] = [];
  private batch: Change[] | null = null;

  addLayer(id: string) { this.layers.set(id, {}); }
  get(id: string, key: string) { return this.layers.get(id)?.[key]; }

  set(id: string, key: string, value: unknown) {
    const layer = this.layers.get(id);
    if (!layer) throw new Error(`unknown layer ${id}`);
    const change = { id, key, before: layer[key], after: value };
    layer[key] = value;
    if (this.batch) this.batch.push(change);
    else this.commit([change]);
  }

  beginBatch() {
    if (this.batch) throw new Error("batch already open");
    this.batch = [];
  }

  endBatch() {
    const changes = this.batch ?? [];
    this.batch = null;
    if (changes.length) this.commit(changes);
  }

  undo(): boolean {
    const changes = this.undoStack.pop();
    if (!changes) return false;
    for (let i = changes.length - 1; i >= 0; i--) this.write(changes[i], changes[i].before);
    this.redoStack.push(changes);
    return true;
  }

  redo(): boolean {
    const changes = this.redoStack.pop();
    if (!changes) return false;
    for (const c of changes) this.write(c, c.after);
    this.undoStack.push(changes);
    return true;
  }

  private commit(changes: Change[]) {
    this.undoStack.push(changes);
    this.redoStack = []; // a new edit invalidates redo
  }

  private write(c: Change, value: unknown) {
    const layer = this.layers.get(c.id)!;
    if (value === undefined) delete layer[c.key];
    else layer[c.key] = value;
  }
}

Say aloud what it skips: undoable layer creation and undo during an open batch.

3. “Keep history under a memory limit.”

Approach: Collapse repeated writes to one key inside a batch into a single change (first “before”, last “after”), and cap the undo stack by dropping the oldest entry. State the Big-O cost of each choice.

4. “Move a layer to a new parent and return canvas order.”

Approach: Store parent and child lists, reject moves that create a cycle, and return order with a pre-order walk. Make the move undoable too.

5. “What if another user edited the same layer?”

Approach: Quote Figma’s principle: if you undo a lot, copy something and redo back to the present, “the document should not change.” Figma’s engineering blog says an undo modifies redo history at that moment, so you never overwrite a collaborator’s later edit.

How to Prepare in 3 Days

  • Day 1: build it cold. Write the class above from a blank file in your interview language in 30 minutes, then trace the three edge cases.
  • Day 2: follow-ups. Add batch collapsing, a history cap and reparenting. Do one plain algorithm problem too; GreatFrontEnd warns “do not skip DSA entirely.”
  • Day 3: timed mock. Run a full 60-minute session in OphyAI Coding Interview, a Premium product, then rehearse narrating trade-offs aloud with follow-up questions in OphyAI Interview Practice. Practice in CoderPad’s sandbox too.

Time plan for 45-60 minutes: about 5 minutes clarifying and writing the history rules, 20 coding set and undo, 10 adding redo and batches, 10 testing aloud, and the rest on follow-ups.

In the live screen, Coding Copilot in the desktop app shows the code, a dry run and the Big O in an overlay left out of screen sharing.

Start practicing →

Common Mistakes

  • Coding before scoping. Ask whether properties can be deleted, whether batches nest and what undo returns when empty.
  • Forgetting the “key did not exist” case. Undo should remove it, not set it to undefined.
  • Never running the code. CoderPad runs it.

Frequently Asked Questions

What coding question does Figma ask in the CoderPad screen?

The most reported prompt is a document of layers with key-value properties: get, set, undo, then redo and batched edits as follow-ups. Some candidates instead report tree ordering or a general algorithm problem. Figma does not publish its questions, so treat these as likely themes rather than a guaranteed prompt.

How long is the Figma CoderPad interview?

Prep guides describe about 60 minutes with one main problem plus follow-ups. Plan to spend the first five minutes clarifying rules and the last ten testing aloud, which leaves about 45 minutes of real coding. Ask your recruiter whether your slot is 45 or 60 minutes so you can pace it.

Which language should I use for the Figma coding screen?

Use the language you write fastest and most correctly. Reported screens use TypeScript, Python or Rust depending on role, and Figma postings list TypeScript, C++, Go, Rust and Python among relevant languages. TypeScript reads naturally for a layer store, but Python is equally fine if you are quicker in it.

How does OphyAI work in a Figma CoderPad interview?

Rehearse the layer store in OphyAI Coding Interview and the narration in Interview Practice. In the live screen, Coding Copilot in the desktop app (Premium) remembers the problem across follow-ups, and Space or Cmd/Ctrl+Shift+L transcribes a question asked out loud. Its overlay does not take the keyboard from CoderPad and is left out of screen sharing, but not hidden from a webcam.

How hard is the Figma CoderPad interview?

Guides rate it around LeetCode medium, but the difficulty comes from length and follow-ups rather than clever algorithms. Candidates who fail usually run out of time or ship a history model that breaks on redo or batches. A clean, tested core with clear trade-offs scores better than a rushed complete version.

Sources and verification notes

Checked October 2026. 1Point3Acres returned 403 and its candidate reports were not read directly; prep-guide details are secondhand and candidate-reported.

Tags:

Figma interview Figma CoderPad interview undo redo coding interview software engineer interview

Coding round at Figma? Coding Copilot reads the problem with one hotkey.

In the OphyAI desktop app, Coding Copilot snaps the problem on your screen and returns an approach, working code, edge cases and the Big O, in an overlay left out of screen sharing. It is part of the Premium plan.

Hidden from screen share and recording; a webcam or a person in the room can still see your screen, and the overlay never takes focus from your editor.