Meta frontend interview questions and process

Thirty-one minutes into the screen, the candidate finished the first problem. Clean solution, tests passed, small optimisation at the end. She sat back, pleased. Then the interviewer said: "Great — next one." There was a next one. There had always been a next one. She had fourteen minutes and had spent seventeen of them on a linked list.

That is the thing about Meta frontend interview questions: the difficulty is rarely the problem itself. It is that Meta packs two problems into a 45-minute coding round and expects both, which turns a solvable question into a pacing exercise. Add a frontend system design round that lands on a news feed, React questions that go past the API into the reconciliation model, and a "people" round graded on collaboration rather than code, and you get a loop that punishes anyone who prepared only by reading. I built Greenroom after freezing in an interview I had studied hard for, so this guide is about what Meta asks and how to say it out loud under a clock.

The Meta frontend engineer interview process in 2026

Meta runs a fairly uniform loop across offices, including London, Singapore and the India-facing roles hired into other regions. What candidates consistently report as the Meta frontend interview process:

• Recruiter screen — 20-30 minutes, level calibration and logistics. Ask here whether your loop is generalist or frontend-specialised; it changes what you study.
• Technical screen — 45 minutes, usually two coding problems on a shared editor with no execution. Sometimes one coding problem plus a short UI task.
• Onsite (virtual, one day) — typically two coding rounds, one frontend system design round, and one behavioral round Meta calls the people round.
• Hiring committee — your packet is reviewed by people who never met you, which is why the interviewer's written notes matter more than the vibe in the room.
• Team matching — at Meta the offer and the team are separate steps. You can pass the loop and then wait weeks for a match.

That last point catches people out. Passing is not placement. Our Meta interview preparation guide covers the company-wide loop, and the Meta data engineer guide covers the data side of the same process.

The coding rounds: two problems in 45 minutes

The unit of failure here is time, not difficulty. Most problems sit at LeetCode medium; a few edge into hard. What breaks candidates is spending twenty-five minutes on the first one.

The pacing that works: two minutes clarifying, three minutes stating the approach and complexity out loud, twelve to fifteen minutes coding, two minutes walking through an example. If you are past twenty minutes on problem one, say so — "I want to leave room for the second, so let me finish this quickly and move on" is a signal of judgment, not weakness.

Two other Meta-specific rules. First, the editor usually does not run your code, so you are your own compiler — walk an input through the function line by line at the end, out loud. Second, Meta interviewers rarely tell you your solution is wrong; they ask a mild question near the bug. Treat every mild question as a red flag.

Frontend candidates get DOM-flavoured problems as often as pure algorithms — flatten a nested structure, implement an event emitter, debounce, a deep clone, a promise pool with limited concurrency:

// classic Meta-flavoured warm-up: run N async tasks with a concurrency cap
function pool(tasks, limit) {
  let i = 0, active = 0;
  const results = new Array(tasks.length);
  return new Promise((resolve, reject) => {
    const next = () => {
      if (i === tasks.length && active === 0) return resolve(results);
      while (active < limit && i < tasks.length) {
        const idx = i++;
        active++;
        tasks[idx]().then((v) => { results[idx] = v; }, reject)
          .finally(() => { active--; next(); });   // free the slot, refill it
      }
    };
    next();
  });
}

Say the invariant out loud while you type it: "active never exceeds limit, and every settled task refills exactly one slot." Interviewers grade the sentence as much as the code. Our DSA coding interview preparation guide covers the algorithm list and common coding interview mistakes covers the ways this round is usually lost.

Frontend system design at Meta: design a news feed

If you get one frontend design prompt at Meta, it is a feed — the news feed, a comments thread, a notifications panel, a photo grid. This is home turf for them, so vague answers land badly.

• Clarify the product first. Mobile web or desktop? How many items per page? Are posts editable after render? Is ordering server-decided or client-decided? Two minutes here saves the round.
• Data fetching and pagination. Cursor-based, not offset — say why: offsets duplicate and skip items when the underlying list mutates between requests. Mention prefetching the next page before the user reaches the bottom.
• Rendering long lists. Windowing or virtualisation, and the honest cost: variable-height items make measurement hard, and virtualised content is invisible to in-page find and to some assistive technology unless you handle it.
• Normalised client cache. The same post appears in the feed, in a permalink and in a notification. Store entities by ID once and render from that, or your like count disagrees with itself.
• Optimistic updates. A like should feel instant. Describe the rollback path when the request fails, and what the user sees.
• Images and media. Responsive sources, lazy loading below the fold, explicit dimensions to avoid layout shift, and a low-quality placeholder. Meta cares about this because they measure it.
• Perceived performance. Skeletons over spinners, streaming the shell before the data, and measuring with real-user metrics rather than a lab score.
• Accessibility. Keyboard traversal of a long feed, focus management when items insert above the viewport, and live-region announcements for new content.

Meta's own public engineering writing on React Server Components and on their web performance work is unusually detailed and worth reading before this round. The Meta frontend engineer prep page has a round-by-round checklist, and our system design interview guide covers the shared vocabulary.

React and JavaScript depth Meta expects

Meta wrote React, so surface-level API knowledge is not a differentiator. The questions go one layer down:

• Reconciliation. Why keys matter, what happens when you use an array index as a key on a reorderable list, and why a changed component type unmounts the subtree.
• Why did this re-render. Reference equality, context value identity, and how a new object literal in props defeats memo.
• useEffect semantics. Dependency arrays, cleanup, stale closures, and why an effect that sets state from a prop is usually a design smell.
• Concurrent rendering. Transitions, interruption, and what "the render can be thrown away" means for anything you do outside pure render.
• Event loop and microtasks. Ordering of promises versus timers, and why one long synchronous task blocks paint entirely.
• Closures, this, prototypes. Implementing bind, debounce and a small pub-sub from memory is table stakes.

Our React interview questions guide and JavaScript interview questions guide cover this ground in answer form.

The people round: collaboration, not code

Meta's behavioral round — often called the people round — is graded on how you work with others, how you handle conflict and ambiguity, and whether you can be honest about a failure without deflecting. It is a real round with a real score, and it is the one candidates prepare least.

Prepare five stories with numbers in them: a conflict with a peer that you resolved, a project that slipped and what you changed, a time you were wrong in public, a piece of work you drove without authority, and something you shipped that mattered. Rehearse each one out loud to two follow-ups deep, because the follow-up is where memorised answers fall apart.

Our behavioral interview questions guide covers structure and tell me about a conflict with a coworker covers the question Meta asks most reliably.

LeetCode, GreatFrontEnd, ChatGPT — where each fits

An honest map of the prep stack for this specific loop:

• LeetCode — necessary. Meta-tagged mediums, done in pairs under a 45-minute timer so you train pacing rather than just correctness.
• GreatFrontEnd — the closest thing to Meta's UI-flavoured coding problems, and the best source for implement-debounce-style questions.
• MDN — the reference for IntersectionObserver, requestIdleCallback, and the loading and decoding image attributes you will cite in the design round.
• Meta's engineering blog and the React docs — the design round rewards knowing how they think about rendering.
• ChatGPT — genuinely useful for generating problems and critiquing pasted code. It will not tell you that you have spent nineteen minutes on problem one, because it is not holding a clock.
• Greenroom — the spoken layer. Ari, the AI interviewer, runs the round out loud, interrupts, asks the follow-up, and scores structure and clarity. Fair tradeoff: Ari will not diff your JSX line by line, so pair it with LeetCode reps and real builds.

How to prepare for the Meta frontend interview

• Week 1 — Meta-tagged LeetCode mediums in pairs, timed at 45 minutes for two. Every session ends with you saying the complexity out loud.
• Week 2 — the JavaScript mechanism set: bind, debounce, a pub-sub, a promise pool, a deep clone, all from memory, plus reconciliation and re-render questions answered in ninety seconds each.
• Week 3 — design a feed, a comments thread and a notifications panel out loud, constraints first. Build one virtualised list yourself and profile it.
• Final week — five people-round stories with numbers, rehearsed to two follow-ups deep, two full spoken mocks, and the role-specific prep page the night before. No new material in the last 48 hours.

Interviewing across comparable loops? The Google backend engineer guide covers a similar bar with a different rhythm, the Uber frontend engineer guide covers real-time UI, and the Atlassian frontend engineer guide covers accessibility and design systems.

Frequently asked questions

What is the Meta frontend engineer interview process?

Candidates report a recruiter screen, a 45-minute technical screen that usually contains two coding problems, and a virtual onsite of roughly four rounds — two coding, one frontend system design, and a behavioral people round. A hiring committee that never met you reviews the written feedback, and team matching happens after the offer decision, so passing the loop and getting placed on a team are two separate steps.

How many coding questions does Meta ask in one interview?

Two problems in 45 minutes is the standard format for the coding rounds, which is why pacing matters more than raw difficulty. Aim for roughly twenty minutes per problem including clarification and a verbal walkthrough, and if you are running long on the first one, say so and move on — that reads as judgment rather than failure.

What frontend system design questions does Meta ask?

Feed-shaped prompts dominate: design the news feed, a comments thread, a notifications panel or a photo grid. A strong answer clarifies the product first, then covers cursor-based pagination, list virtualisation with its honest costs, a normalised client cache so the same entity does not disagree with itself, optimistic updates with a rollback path, image loading and layout shift, perceived performance, and accessibility for a list that changes under the user.

What React questions does Meta ask frontend engineers?

Meta goes below the API surface: reconciliation and why keys matter, what breaks when an array index is used as a key on a reorderable list, why a specific component re-rendered in terms of reference equality and context identity, useEffect cleanup and stale closures, and what concurrent rendering means for work you do outside pure render. Implementing bind, debounce and a small pub-sub from memory is treated as table stakes.

What is the people round at Meta?

It is Meta's behavioral round, scored on collaboration, handling conflict and ambiguity, and whether you can describe a failure without deflecting. Prepare five real stories with numbers — a conflict you resolved, a project that slipped, a time you were publicly wrong, work you drove without authority, and something you shipped that mattered — and rehearse each out loud to two follow-ups deep.

Is the Meta frontend interview hard?

It is a high bar, but the difficulty is unusual in shape: individual problems are mostly LeetCode medium, and the pressure comes from fitting two of them into 45 minutes in an editor that does not run your code. The design round expects genuine depth on feeds specifically, and the people round is a real scored round rather than a formality.