A practical roundup of 14 deduplicated firsthand Figma SWE internship reports, from the Byteboard years to the CoderPad era..

Coverage: Software Engineer Intern roles; OA, recruiter check-ins, technical screens, coding, technical design, behavioral, and final/virtual onsite stages; primarily United States reports from September 2020 through October 2026.

Good luck!

Online assessments (OA)

OA 01: The first AI-assisted CoderPad signals （finally found one!!

Report dates: August–October 2026 · Role: Winter or Summer 2027 SWE Intern · Status: In process / rejected after OA

1. Candidates reported a 90-minute CoderPad assessment after recruiter outreach.
2. One described building a system from scratch and continuously explaining the reasoning. They felt the assessment went well but were rejected.
3. Another described receiving a scope and design document, then using the available AI to implement several features.
4. The advice from that account was to decompose the work, discuss tradeoffs, and explicitly check edge cases.
5. A separate candidate said their assessment was not a traditional LeetCode test and described the signal as AI fluency.
   A recruiter invitation remains the source of truth for allowed tools. Public reports do not yet establish one universal 2027 path: at least one candidate said the OA was skipped and they went directly to two live technical interviews.

OA 02: Revision History （coding + data structure design oa question :)

Revision History asks you to build edit history for a document editor. The prompt suggested a few method names, but candidates could use a different API if another design made more sense. The exact prompt was not shared, so the version below is a close practice exercise, not a word-for-word copy.

What we know

1. Build revision history for a document editor.
2. Support several operations through a small API.
3. Use the sample API or replace it with a clearer design.
4. AI tools were allowed, but candidates still had to explain their choices.

A practical version to try

1. Support insert, delete, and replace.
2. Store enough information to apply and reverse every edit.
3. Add methods to apply an edit, read the document, undo, and redo.
4. Let several edits count as one revision.
5. Clear redo history after a new edit.
6. Compare full snapshots, forward operations, inverse operations, and periodic snapshots with deltas.
7. Explain the time and memory cost when the history holds millions of small edits.
8. Test empty history, repeated undo and redo, overlapping ranges, edits that change length, and a new edit after undo.
9. If you use AI, check every suggestion, add focused tests, and be ready to explain your data structures.

This stays close to the details that were shared. The exact method names, examples, and hidden tests are still unknown.

03, 04, AND 05 ARE FROM 2025. THEY USED BYTEBOARD BACK THEN

OA 03: Finishing every part was helpful, not a published cutoff

Report date: November 2025 · Role: Summer 2026 SWE Intern

1. One candidate completed two of three implementation steps, documented the unfinished step, and was rejected a few days later.
2. Another candidate reported completing all three steps and received a final-round invitation after roughly ten days.
3. Figma's instructions reportedly said candidates were not expected to finish every part.
   Two outcomes are not enough to invent a cutoff. The safer reading is that completion, document reasoning, code quality, and communication were evaluated together.

OA 04: The 90-minute 2025 version

Report date: September 2025 · Role: SWE Intern · Location: New York · Result: Rejected after OA

1. The application began with written questions about Why Figma, preferred engineering teams, and a project that best demonstrated programming ability.
2. The Byteboard was split into 30 minutes for a technical design document and 60 minutes for implementing related functionality.
3. The candidate found the document section especially tight and felt there was not enough time to think deeply before coding.
   The mechanics remained recognizable, but the total timer had tightened from the roughly 110-minute 2021 account to 90 minutes.

OA 05: The detailed 2021 Byteboard account

Interview period: 2020 recruiting for Summer 2021 · Role: SWE Intern · Result: Rejected after final interviews

1. Part 1 lasted about 40 minutes. The candidate read a project proposal with several implementation options, left comments, answered comments from teammates, and wrote a conclusion choosing an approach.
2. Part 2 lasted about 70 minutes. She chose Python, downloaded a small multi-file codebase, and was asked to implement four functions connected to the project in Part 1.
3. She finished the three highest-priority functions and used comments to explain how she would finish the fourth.
4. A recruiter later said the assessment rubric had flagged attention to detail, while recognizing strong coding. The advice for the final was to ask questions, test the code, and work collaboratively.
   This is the richest public account of the old OA. It shows that unfinished code was not automatically fatal when the candidate preserved priorities and reasoning.

Live interview question bank

Existing-codebase coding

1. Complete methods in an existing class structure. Multiple 2021 accounts describe receiving classes, tests, and missing functions rather than starting from a blank editor. A separate early report described document and layer operations in a Figma-style model, without preserving the original API.
2. Understand before editing. Candidates had to form a mental model of the code, identify the intended data structure, implement incrementally, and run the supplied tests.
3. Handle follow-ups and edge cases. One candidate was repeatedly asked how the implementation behaved on additional cases after reaching a working solution.

Data structures and algorithms

1. BFS on a tree. One 2022 intern report identifies a breadth-first tree problem, but does not preserve the complete prompt or input format.
2. Recursion. The same report names a separate recursion problem and says neither technical solution reached 100% completion.
3. Graphs, trees, and hash maps. A 2023 offer-holder described both technical interviews as roughly LeetCode-medium difficulty in these areas.
4. Symmetric binary tree. One anonymous Summer 2026 report names checking whether a binary tree is symmetric. This is one sighting, not a recurring intern question.
5. Iterative algorithms and efficiency. A 2023 OA-only report names these evaluation areas without preserving a runnable prompt. A separate Byteboard completer remembered an O(log n) search over ordered entries, but not the entry schema or return contract.

Figma-flavored product and design tasks

1. Search-result highlighting. One early report remembers designing or implementing highlighting behavior, but not the contract, query semantics, or rendering rules.
2. File organization. The same report names file organization as another Figma-related feature prompt without enough detail to reconstruct it faithfully.
3. Browser editor architecture. A Summer 2026 offer-holder describes one technical round as architecting a browser editor. No complete scale, collaboration, rendering, or persistence requirements were disclosed.
4. Database / SQL-style technical design. One 2021 final included a database-oriented discussion. The preparation packet reportedly said interviewers could teach the SQL needed, suggesting that reasoning mattered more than memorized syntax.
5. Current live technical signal. One 2027-cycle candidate was told to expect two back-to-back interviews: AI-assisted debugging in an existing TypeScript codebase and a DSA round. Their completed-interview details were not public at research time.

Behavioral and application questions

1. Why Figma?
2. Which engineering areas or teams interest you most, and why?
3. Walk through the project that best shows your programming ability: goal, ownership, technologies, challenges, and result.
4. Describe a technical decision you would reconsider today.
5. Describe a time you owned a problem outside your expected scope.
6. Explain how you collaborate, ask for feedback, test your work, and respond when an interviewer points out an edge case.
7. Be ready to connect your interest to Figma's product rather than giving a generic design-company answer.

14 detailed candidate timelines, loops, and screens

01: Implementing features from a scope and design document

Report date: October 2026 · Role: SWE Intern, 2027 cycle · Result: Not disclosed

1. The assessment was AI-assisted.
2. The candidate received scope plus a design document and implemented several features.
3. They recommended breaking the problem into smaller units, narrating tradeoffs, and explicitly considering alternate and edge cases.
4. At the time of the report, they had not received a result.

02: The 90-minute AI build that ended after OA

Report date: September 2026 · Role: SWE Intern, 2027 cycle · Result: Rejected after OA

1. The CoderPad lasted 90 minutes.
2. The candidate described building a system from scratch with AI assistance.
3. They emphasized that the candidate still had to explain the architecture and development decisions instead of accepting an unexplained one-shot output.
4. They felt the assessment went well but did not advance.

03: Summer 2026 offer — DSA plus browser-editor architecture

Interview period: Summer 2026 · Role: SWE Intern · Location: San Francisco · Result: Offer

1. Byteboard preceded the onsite.
2. A relaxed 30-minute behavioral conversation was conducted by a senior engineer.
3. One technical interview focused on data structures.
4. Another focused on architecting a browser editor.
5. The candidate believed domain knowledge helped.

This anonymous report is concise, so it supports the round shape but not a detailed browser-editor prompt.

04: Summer 2026 onsite exposed a graphics gap

Interview period: Summer 2026 · Role: SWE Intern · Location: San Francisco · Result: No offer

1. The candidate reached the onsite and felt the behavioral round was fine.
2. They believed limited graphics knowledge hurt them in the technical rounds.
3. The two preserved questions were why they applied to Figma and checking whether a binary tree is symmetric.

This is the only admitted intern report naming Symmetric Tree, so it should stay a single-source lead.

05: Three of three steps, then the final invitation

Report date: November 2025 · Role: Summer 2026 SWE Intern · Result: Advanced after OA

1. This candidate completed all three steps.
2. They waited about ten days without a decision.
3. An update later confirmed an invitation to the final stage.
4. They did not publish the final-round questions or ultimate outcome.

06: Two of three steps, then a quick rejection

Report date: November 2025 · Role: Summer 2026 SWE Intern · Result: Rejected after OA

1. The candidate completed two of three implementation steps.
2. They believed the code comments were decent but described the design-document work as weak.
3. They completed the assessment on a Tuesday night and received the rejection on Friday morning.

07: The 2025 New York time-crunch report

Report date: September 2025 · Role: SWE Intern · Location: New York · Result: Rejected after OA

1. Greenhouse questions covered Why Figma, preferred teams, and a representative programming project.
2. The Byteboard allotted 30 minutes to the design document and 60 minutes to implementation.
3. The candidate felt the reading-and-reasoning section left too little time for careful thinking and did not advance.

08: The 2025-cycle product-feature assessment

Report date: September 2024 · Role: SWE Intern, 2025 cycle · Result: Not disclosed

1. Candidates first received an online process form and a candidate slide deck.
2. The assessment was described as implementing product features from a design challenge rather than solving isolated algorithm puzzles.
3. One candidate who completed it said the experience was reasonable but time was a concern.

09: A 2023 offer after the two-part OA

Report date: October 2023 · Role: SWE Intern · Location: San Francisco · Result: Offer

1. A recruiter questionnaire covered logistics.
2. The roughly two-hour Byteboard combined design-document comments and recommendations with related implementation work.
3. The final lasted about three hours: a 30-minute behavioral interview and two 60-minute technical interviews.
4. The candidate characterized the coding as LeetCode-medium-level work involving graphs, trees, and hash maps.

10: A three-week 2023 process

Interview period: September 2023 · Role: SWE Intern · Result: No offer

1. Applied online.
2. Completed Byteboard.
3. Had a recruiter check-in.
4. Completed three back-to-back final interviews: two technical and one behavioral.
5. The preserved behavioral question was Why Figma?

The full process reportedly took about three weeks.

11: BFS, recursion, and incomplete solutions

Report date: October 2022 · Role: SWE Intern · Result: No offer

1. The final consisted of two technical interviews and one behavioral interview.
2. One technical problem used BFS with a tree.
3. Another was described only as a recursion problem.
4. The candidate did not finish either problem completely and rated the overall difficulty as medium.

12: Classes, methods, design, then engineering values

Report date: October 2021 · Role: SWE Intern · Result: No offer

1. Byteboard came first.
2. The onsite contained two coding interviews and one technical-design interview.
3. The coding questions supplied a class structure and asked the candidate to implement particular methods using standard data structures and some algorithms.
4. A 30-minute engineering-values conversation with a hiring manager followed the technical loop.

13: The fully narrated Summer 2021 journey

Report date: February 2021 · Role: SWE Intern · Result: Rejected

OA

1. Forty-minute design-document review.
2. Seventy-minute implementation in a small Python codebase.
3. Three of four prioritized functions completed; the fourth explained in comments.

Final interviews

1. A CoderPad round supplied several classes, tests, and missing functions based on a real problem from an engineering team.
2. A database-oriented technical-design conversation followed.
3. A second codebase round again required understanding existing code and implementing several functions.

The candidate received a rejection a few days later. Her own reflection was that communication and coding from scratch were harder to demonstrate when so much unfamiliar code arrived at once.

14: The 2020 non-LeetCode onsite

Report date: September 2020 · Role: SWE Intern · Result: No offer

Process

1. Byteboard assessment.
2. Two technical coding interviews.
3. One system-design interview.

The candidate described the questions as Figma-specific rather than standard LeetCode, while still using familiar structures such as dictionaries and binary search trees.

What repeated often enough to prioritize

1: Practice until automatic

1. Read a small unfamiliar codebase before changing it.
2. Use trees, graphs, recursion, BFS, hash maps, arrays, and sets comfortably.
3. Write tests early, cover edge cases, and leave useful comments when time expires.
4. Explain assumptions and complexity while coding, not afterward.

2: Be ready to explain deeply

1. Compare implementation options in a design document and defend one choice.
2. Model undo, redo, revisions, and batches with explicit invariants.
3. Debug an existing TypeScript codebase while keeping control of an AI assistant.
4. Walk through one project with precise ownership, tradeoffs, failures, and measurable outcomes.

3: Higher-level differentiators

1. Understand the building blocks of a browser-based editor: document models, rendering, event handling, persistence, and performance.
2. Use Figma and FigJam enough to discuss real product behavior rather than an abstract collaborative app.
3. Connect technical decisions to collaboration among engineers, designers, PMs, and QA.

Final checklist

OA and AI coding

☐ Rehearse a 30-minute design-doc review followed by a 60-minute implementation.

☐ Read an unfamiliar multi-file project; test early and document unfinished work.

☐ Practice an AI-assisted build; own architecture and test edge cases.

Coding and design

☐ Review BFS/DFS, tree recursion, graphs, hash maps, and symmetric trees.

☐ Extend existing classes while explaining complexity and invariants.

☐ Design revision history with snapshots or operations; cover undo, redo, batches, and branching.

☐ Prepare a browser-editor discussion: document model, rendering, persistence, and recovery.

Behavioral

☐ Prepare Why Figma from a product observation.

☐ Prepare stories on feedback, conflict, extra ownership, and a decision you would revisit.