Meta Frontend Engineer Interview: Every Round, Decoded

The Meta frontend engineer interview isn't a standard SWE loop with a fresh coat of paint. The rounds are different, the coding problems are different, and the evaluation criteria are different. Treat it like a generic coding interview and you'll flame out on something you've been writing for years: JavaScript.

Specifically, the JavaScript underneath the framework you've been hiding inside since 2019.

---

The Full Process at a Glance

The loop typically runs four to six rounds spread across a recruiter call, a technical phone screen, and a full onsite:

Round	Format	Duration	Focus
Recruiter call	Async / Zoom	20-30 min	Background, process, timeline
Technical screen	CoderPad	45 min	1-2 JS/DSA problems
Onsite: Coding 1	CoderPad	45 min	JS internals, DOM, browser APIs
Onsite: Coding 2	CoderPad	45 min	DSA with frontend framing
Onsite: UI Design	Whiteboard / Figma	45 min	Frontend system design
Onsite: Behavioral	Zoom	45 min	Meta's five values

As of late 2025, Meta has been piloting an AI-assisted coding round that replaces one of the two traditional onsite coding sessions for some loops. In that format you get a file directory, terminal access, a unit testing interface, and integrated AI assistance. The AI can write code, but the interviewer's questions shift to production readiness: concurrency, error handling, scalability, test coverage. Getting to a working solution fast matters more than usual in this round.

Total calendar time from application to offer is typically four to six weeks. If you're targeting the standard generalist SWE path at Meta, the Meta software engineer interview guide covers what changes between the two loops.

---

The Technical Screen

The screen is 45 minutes in CoderPad. Important: CoderPad at Meta is a plain text editor with no execution environment. You write code, you trace through it mentally, and you narrate. Candidates who need to run their code to know if it works struggle here.

Expect one or two problems. The first is usually a warm-up in the easy-to-medium range; the second is a medium. Topics at this stage:

• Array and string manipulation
• Hashtables and frequency counting
• Basic tree or graph traversal
• Classic JS questions like flattening nested arrays, implementing a simple event emitter, or describing closure behavior

One question that comes up repeatedly: write a flatten function for an arbitrarily nested array. Not a hard problem. The question is whether you handle edge cases and whether you can narrate the call stack out loud without running it first.

---

Onsite Coding Round 1: The Round That Humbles React Developers

This is where frontend engineers get tripped up. The problem set here is not "solve a LeetCode medium in JavaScript." It's "show us you actually understand the runtime you've been working in every day."

Reported questions from recent interview cycles:

• Implement debounce and throttle from scratch (timers, closures, state inside a function)
• Given a JSON representation of a DOM tree, write a function to render it into actual DOM nodes
• Given two identical DOM tree structures A and B and a node from A, find the corresponding node in B
• Implement an event delegation system: attach a single listener to a parent, handle events from dynamically added children
• Write a function that cancels all pending setTimeout calls registered via a custom wrapper
• Build a simple observable/subscription system (subscribe, unsubscribe, notify)

The thread running through all of these is vanilla JavaScript. Not React, not Vue, not any framework. Meta wants to know you understand closures, the event loop, this binding, prototype chains, and how the DOM is structured. If your mental model of the frontend is "I import components and wire up state," you will hit a wall here.

A few JavaScript gotchas that interviewers love to probe:

// What does this print, and why?
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// Prints 3, 3, 3. var is function-scoped, not block-scoped
// Fix: use let, or wrap in an IIFE

This one feels obvious when you're reading a blog post about it. It feels much less obvious when someone is watching you type with a blank expression. The answer takes two seconds; getting there without a nervous pause takes practice.

// What's wrong with this deep clone?
const clone = JSON.parse(JSON.stringify(obj));
// Drops: undefined, functions, Symbol keys
// Corrupts: Date becomes a string, NaN becomes null
// Throws: circular references

Interviewers expect you to catch these without prompting. If you reach for JSON.parse(JSON.stringify(...)) and don't mention the limitations, that's a flag. You're supposed to know what your tools can't do.

The closure traps that derail you in Round 1 are the same ones that fill LinkedIn with "JavaScript Interview Coding Task Question Day 47" posts. The difference is you have to explain them live.

---

Onsite Coding Round 2: DSA with a Frontend Frame

Round 2 is closer to a standard SWE coding interview, except the problems are framed around frontend concepts. The DOM is a tree. A React component hierarchy is a tree. A router's URL structure is a tree. Meta's interviewers know this and choose problems accordingly.

The critical insight: dynamic programming does not appear in Meta's frontend coding rounds. What does appear, repeatedly:

• Tree traversal: level-order (BFS), DFS, path finding, right-side view
• Graph traversal: connected components, BFS shortest path, deep copy of a graph via BFS + hashmap
• Hashmaps: frequency counting, deduplication, group-by operations
• Recursion on nested structures: nested objects, component trees, JSON schemas

Meta's overall question distribution leans approximately 60% medium difficulty. The frontend loop is even lighter on hard problems than the SWE loop. The goal is not exotic algorithmic difficulty. It's completeness, correctness, and communication under time pressure. For a deeper breakdown of why mediums dominate and what that means for your prep, see coding interview difficulty is 60% medium.

Two problems in 45 minutes means roughly 17-20 minutes per problem including explanation time. You cannot spend 10 minutes exploring brute force if you intend to reach the optimal solution. State a clear approach, confirm with the interviewer, then code.

# Flatten a nested list structure (BFS or recursive DFS)
# Input: [1, [2, [3, 4]], [5]]
# Output: [1, 2, 3, 4, 5]

def flatten(lst):
    result = []
    def dfs(node):
        for item in node:
            if isinstance(item, list):
                dfs(item)
            else:
                result.append(item)
    dfs(lst)
    return result

// Right-side view of a binary tree (BFS, take last node per level)
function rightSideView(root) {
  if (!root) return [];
  const result = [];
  const queue = [root];
  while (queue.length) {
    const levelSize = queue.length;
    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift();
      if (i === levelSize - 1) result.push(node.val);
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
  }
  return result;
}

Default to JavaScript in these rounds. Meta's frontend interviewers expect it, and it saves you from translating your mental model mid-problem. For a full breakdown of which DSA topics frontend roles actually require versus which ones you can deprioritize, see DSA for frontend engineers.

---

The UI Architecture Round

This is the design interview. It runs 45 minutes and can go one of two directions: component architecture or frontend system design.

Component architecture questions ask you to design a specific UI from scratch: an autocomplete, an infinite scroll feed, a multi-step form wizard, a notification system. You're evaluated on how you decompose the problem into components with clear interfaces, your state management strategy, API design, accessibility and error states, and performance considerations like virtualizing long lists or debouncing search inputs.

Frontend system design questions zoom out further: design the client-side architecture for a real-time collaborative editor, or a metrics dashboard that aggregates data from 10 sources. These require you to think about WebSockets vs polling, optimistic updates, cache invalidation, and failure states.

A useful framework: Requirements, Architecture, Data Model, Interface, Optimizations (RADIO). Start with clarifying questions to scope the problem, then propose an architecture, then drill into specifics. An interviewer who sees you jump to component details before establishing requirements will mark it down.

---

The Round Where "I Worked Hard" Won't Cut It

Meta's behavioral round is scored against five core values: resolving conflict, growing continuously, embracing ambiguity, driving results, and communicating effectively. Every question in this round maps to one of these. The interviewer will push past hypotheticals fast, so prepare actual stories.

The STAR format (Situation, Task, Action, Result) works here. Prepare three to four strong stories that flex across multiple values. A story about shipping under a hard deadline with incomplete requirements can cover ambiguity, results, and communication depending on where you steer it.

One thing that distinguishes Meta: they probe for scale. "Tell me about a time you drove a project forward" is immediately followed by "How many engineers were involved? What was the impact in numbers?" Have your numbers ready before the call, not while you're being asked for them.

---

The Mistakes That End Loops

Reaching for frameworks. "I'd use React's useEffect for this" is not an answer when the question asks you to implement an event listener system in vanilla JS. Know the platform underneath the framework.

Solving one problem slowly. Two problems per round is not a guideline, it's the expectation. Candidates who solve one problem thoroughly and run out of time get marked down. Get to working code for problem one, then move.

Ignoring edge cases in the trace. Since there's no execution environment, edge cases your code silently breaks on become visible when you trace manually. Cover nulls, empty inputs, and circular references out loud before the interviewer asks.

Treating the UI design round like an SWE system design. Talking about database sharding when the question is about a frontend feed component misses the point. Stay in the client-side layer unless the problem explicitly pulls you out.

Generic behavioral stories. "I worked on a team that had a disagreement" with no specifics gives the interviewer nothing to write. Vague stories leave rubric boxes empty. The same principle applies in every coding round: silence and vague narration hurt your score even when your code is correct. Technical interview communication explains the mechanism in detail.

Meta's interview is basically this job posting made real. They want the React thinking and the vanilla JS guts underneath it. Both. At the same time. On a whiteboard.

---

Meta Frontend Interview Prep Plan

6+ weeks out: Cover the JavaScript fundamentals. Closures, this, prototype chain, event loop, promises and async/await internals, var vs let vs const scope. Read the MDN documentation on the EventTarget API and the DOM tree structure. Not skim. Read.

4-5 weeks out: Work through tree and graph problems in JavaScript on LeetCode. Focus on BFS, DFS, level-order traversal, connected components, and hash table patterns. Target mediums. Meta's distribution is roughly 26 easy, 60 medium, 14 hard across their tagged questions. Hards are not the focus.

2-3 weeks out: Shift to frontend-specific practice. Implement debounce, throttle, a deep clone, a DOM renderer from JSON, an event emitter, and a simple pub/sub system. Do these in vanilla JS without looking at solutions first. Getting stuck is the point.

1 week out: Practice UI design walkthroughs out loud. Autocomplete, infinite scroll, a real-time feed. Use RADIO. Prep your behavioral stories with concrete numbers. Run mock interviews to get comfortable with the CoderPad environment and the two-problems-per-round pace. SpaceComplexity lets you run voice-based mock interviews with rubric feedback so you can hear whether your explanations are landing before the real thing.

Day before: Stop learning new material. Review your pattern notes. Read your behavioral stories one more time. Sleep.

---

Further Reading

• Meta Careers: Engineering at Meta
• Front End Interview Handbook
• MDN Web Docs: EventTarget API
• MDN Web Docs: Document Object Model
• MDN Web Docs: Closures