Meta (Facebook) Interview Prep: Coding Rounds Explained

· Written by

Every FAANG interview tests problem solving. Meta’s tests problem solving at speed. The defining fact of the Meta loop is arithmetic: two coding problems in a 45-minute round, minus intros and questions, leaves roughly 17-18 minutes per problem: optimal solution, explained out loud, in an editor that doesn’t compile. Google gives you one hard problem and watches you think; Meta gives you two mediums and watches you execute.

That changes how you should prepare. Here’s the format, the topics, and a realistic plan.

The Meta Interview Format

For software engineers (E3-E6), the pipeline looks like this:

  1. Recruiter screen: non-technical; background and level calibration.
  2. Technical phone screen: 45 minutes, one interviewer, usually two problems in CoderPad. This filters more candidates than any other stage.
  3. Onsite loop, typically four to five rounds, which Meta names internally:
    • 2× Coding (“Ninja”): two problems each, same format as the screen.
    • 1× System design (“Pirate”): for E4 and above. E3/new-grad loops usually swap this for another coding round.
    • 1× Behavioral (“Jedi”): motivation, collaboration, and how you handle conflict and ambiguity.

Two format details trip people up. First, you don’t run your code. The editor has no compiler or test runner, so correctness is established by you, tracing through examples line by line. Candidates raised on run-and-fix debugging struggle here. Second, interviewers grade signal: at the debrief they need concrete evidence about your coding, problem solving, verification, and communication. A correct solution delivered silently produces weak signal; a fast, narrated, self-tested solution produces strong signal. Practice accordingly: out loud, on a timer, without hitting run.

The DSA Topics That Dominate

Meta’s question pool is famously concentrated. More than any other FAANG company, its questions cluster around a few hundred well-known problems, weighted toward mediums. The recurring topics:

  1. Arrays and strings: the biggest bucket by far. Two pointers, sliding window, in-place tricks. Classics like Valid Palindrome II and Move Zeroes live here. Foundations: Day 4: Introduction to Arrays.
  2. Hash maps: Subarray Sum Equals K (prefix sums + hash map) is practically a Meta signature. See Day 23: Hash Tables and our hash map interview problems deep dive.
  3. Trees and BFS/DFS: Binary Tree Vertical Order Traversal, Right Side View, Lowest Common Ancestor. Study Day 14: Binary Trees, Day 16: Tree Traversals, and Day 20: Graph Traversals.
  4. Intervals: merging, inserting, and meeting-rooms variants (worked example below).
  5. Binary search: usually the “on the answer space” flavor rather than plain lookup; our post on binary search beyond sorted arrays covers exactly this. Fundamentals: Day 25: Binary Search.
  6. Heaps and top-K: K Closest Points to Origin appears constantly. See Day 17: Heaps.
  7. Recursion and light dynamic programming: Meta leans on clean recursion more than heavyweight DP; when DP appears it’s usually a classic (Day 30 territory), not an obscure variant.

Hard graph theory, tries, and exotic DP are rare. Meta would rather watch you nail two mediums quickly than grind one hard slowly.

Worked Example: Merge Intervals

A Meta staple, and a good speed benchmark: you should be able to produce this, narrated, in under 15 minutes:

 1def merge(intervals: list[list[int]]) -> list[list[int]]:
 2    """Merge overlapping intervals. O(n log n) time, O(n) space."""
 3    intervals.sort(key=lambda x: x[0])  # sort by start
 4
 5    merged = [intervals[0]]
 6    for start, end in intervals[1:]:
 7        last = merged[-1]
 8        if start <= last[1]:            # overlaps the last merged interval
 9            last[1] = max(last[1], end) # extend it
10        else:
11            merged.append([start, end])
12    return merged

Then verify like a Meta candidate. There’s no run button, so trace it: [[1,3],[2,6],[8,10]] → sort is a no-op → [2,6] overlaps [1,3], extend to [1,6] → [8,10] doesn’t, append. Name the edge cases unprompted: empty input, one interval, touching endpoints ([1,2],[2,3]: does <= merge them? yes, deliberately), full containment ([1,10],[2,3], where the max handles it). That 90-second monologue is worth as much signal as the code.

The Pirate Round: System Design, Briefly

For E4+, one round covers system design (“design a news feed,” “design live comments”). A brief on what matters, since deep coverage deserves its own post:

  • Meta grades the same four signals here: problem navigation, solution design, technical excellence, communication. Drive the conversation: clarify requirements, estimate scale, sketch the data model and APIs, then go deep on two or three components rather than shallow on ten.
  • Expect product-flavored infrastructure (feeds, messaging, notifications) rather than abstract distributed-systems trivia. Read requirements through the lens of billions of reads, heavy fan-out, mobile clients.
  • E5+ candidates: this round frequently decides your level. An E5 coding performance with an E4 design performance gets you an E4 offer, or a reject against E5 expectations.

Budget real preparation time for it if you’re E4 or above; it cannot be crammed in a weekend.

The Jedi Round: Behavioral, by Level

Meta’s behavioral round is lighter than Amazon’s LP gauntlet but far from a formality. Interviewers probe for how you resolve conflict, handle ambiguity, take feedback, and deliver impact, impact being the load-bearing word in Meta’s culture and its performance reviews alike.

Prepare 5-6 STAR-format stories with concrete, quantified results. What “good” looks like scales with level:

  • E3/E4: you executed well, unblocked yourself, grew from feedback, collaborated across your team.
  • E5: you owned a project end to end, influenced adjacent teams, made pragmatic trade-offs under ambiguity.
  • E6: you set direction, resolved organizational conflict, multiplied other engineers.

The most common failure is telling “we” stories. The interviewer is levelling you; be specific about your decisions, your code, your mistakes. And bring a genuine answer for “tell me about a time you disagreed with a teammate.” Meta’s culture prizes open disagreement, and a candidate who’s never disagreed with anyone reads as either unobservant or untruthful.

A Realistic Timeline

Because Meta’s pool is concentrated and its bar is speed, preparation splits cleanly into two phases, and skipping phase one is the classic mistake:

  • Phase 1: fundamentals (4-8 weeks). You cannot be fast on patterns you’re still deriving. Build the toolkit in order: arrays through hash tables, trees, heaps, graphs, binary search, recursion. Our 60-day curriculum sequences exactly this, one topic per day.
  • Phase 2: speed under Meta conditions (3-5 weeks). Drill the frequent-question pool two problems at a time: 35 minutes, out loud, no running code. Verify by tracing. If you can’t finish a medium in ~18 minutes, that’s a fluency gap; go back to the pattern, not just the problem.
  • Final 2 weeks: mock interviews (the two-problem pacing is genuinely different from solo practice), plus Pirate and Jedi prep for your level.

End to end, most candidates need 2-4 months depending on starting point, the same math as any FAANG loop, tilted here toward timed reps. For which resources to layer on top, see our tiered prep resource guide.

Meta’s interview is the most trainable in FAANG: a concentrated question pool, a known format, and a bar defined by execution speed. That’s a preparation problem, and preparation problems have schedules. Start Day 1 free. The speed comes from the fundamentals, and the fundamentals start today.

Two problems, forty-five minutes, no run button. Train like that’s the game, because it is.