Meta Interview Guide (2026)

1Snapshot, read this first#

The one thing to understand about Meta: the bar is speed with correctness.

• You usually get two coding problems in one 45-minute round, so you cannot stall, over-think, or ship a buggy answer.
• Interviewers reward engineers who think out loud, move decisively, and self-correct in real time.
• Solve one problem beautifully and never reach the second and you read as "below the bar for speed," even if nothing you wrote was wrong.
• Hold this in your head: a correct brute force in 8 minutes buys time for the second problem; a flawless optimal that eats 40 does not.

2Getting the call (the part most guides skip)#

Meta hires heavily through referrals and inbound recruiter sourcing. Your goal here is to get a human to read your resume instead of a keyword filter.

Referrals move you to the top of the pile.

• Ask someone in your network to submit you through the internal referral tool.
• Hand them a three-line note on why you fit the team. That note gets pasted into the referral.
• A specific reason ("built the retry pipeline that recovered $1.2M/yr, wants to work on payments infra") lands far harder than "great engineer, you should talk to them."

No referral? Get sourced.

• Apply on the Meta careers site and keep LinkedIn current. Recruiters actively source there and cold-message matching profiles.
• Visible open-source work, a GitHub with real projects, or conference talks get sourced noticeably more, because a recruiter can verify them in thirty seconds.

Resume rules.

• One page for E4, at most two for E5.
• Lead every bullet with impact and a number. A screener spends maybe 10 seconds per resume; every bullet without a number is one they skim past.
• Weak: "Worked on backend services for the payments team." Strong, below.

Rebuilt the payments retry pipeline in Go, cutting failed-transaction retries by 38% and saving ~$1.2M/yr in recovered revenue; owned rollout across 3 regions.

• Notice what it does: the tech (Go), the metric (38%), the dollar outcome ($1.2M/yr), the scope (3 regions, and you owned it).

ATS keywords.

• Mirror the job description. For a Meta backend role that usually means the language (C++, Java, Python, Go, Hack/PHP), plus distributed systems, scalability, latency, and the domain (ads, feed, messaging, infra).
• Do not keyword-stuff a skills soup at the bottom. Weave the terms into real accomplishments so a human and the filter both read them as true.

How people actually get shortlisted at Meta:

• Employee referral (dominates for experienced hires).
• Recruiter inbound from LinkedIn or GitHub.
• Direct application that passes the resume screen.
• University on-campus for E3.

3The loop at a glance#

The "full loop," decoded.

• Meta uses playful internal names: coding is "Ninja," system design is "Pirate," behavioral is "Jedi."
• E5 candidates almost always get a system design round; strong E4 loops frequently include one.
• The behavioral round is run by a senior engineer or an engineering manager and is a real gate, not a formality. People with clean coding rounds have been rejected on "Jedi" alone when their ownership stories were thin.

Here is how a typical loop flows start to finish.

4The coding / technical rounds, patterns, not problems#

Meta coding rounds are two problems per 45 minutes, so each should land in ~15-20 minutes including discussion and testing.

• Difficulty is solid LeetCode Medium, occasionally Medium-Hard. Obscure hard problems are rare.
• They want to see you solve common patterns cleanly and fast, because that is the job: a stream of well-understood problems you ship correctly under time pressure.

The patterns Meta reuses most:

• Arrays and strings, two pointers, sliding window: subarray sums, longest substring without repeats, merge intervals.
• Hash maps for O(1) lookup: group/dedupe/count problems, two-sum variants, anagram grouping.
• Trees and graphs, BFS/DFS: level-order traversal, lowest common ancestor, clone graph, number of islands, course schedule (topological sort).
• Binary search: on sorted arrays and on the answer space (for example, minimize the max load).
• Heaps and top-K: k closest points to origin, merge k sorted lists, task scheduler.
• Recursion and backtracking: subsets, permutations, combination sum, generate valid parentheses.
• Intervals and stacks: meeting rooms, next greater element, valid parentheses matching.
• A few classics appear often enough to study by name: "Valid Palindrome," "Merge Intervals," "Binary Tree Vertical Order Traversal," "Subarray Sum Equals K," "Random Pick with Weight," "Lowest Common Ancestor of a Binary Tree." If you have not done those six specifically, do them this week.

Where to weight your practice.

• Dynamic programming shows up but is less central here than at some other companies.
• Graphs, trees, and heaps are more frequent, so spend your reps there.
• Know DP basics (1D and simple 2D), but do not burn three weeks on knapsack variants at the expense of BFS fluency.

Here is the shape I want your brain to reach for on a top-K problem, so the pattern is muscle memory rather than something you rediscover live:

import heapq

def k_closest(points, k):
    # max-heap of size k keyed by negative distance
    heap = []
    for x, y in points:
        d = x * x + y * y          # skip sqrt, order is identical
        heapq.heappush(heap, (-d, x, y))
        if len(heap) > k:
            heapq.heappop(heap)    # drop the farthest so far
    return [(x, y) for _, x, y in heap]

# Time: O(n log k)   Space: O(k)

• Memorize the move, not the problem: a bounded heap of size k gives O(n log k) instead of O(n log n), and you say that complexity out loud as you write it.

How to practice.

• Do ~100-150 LeetCode Mediums, grouped by pattern rather than random. Use Meta's tagged list and the "Top Interview" sets.
• Practice on a plain editor with no autocomplete and no run button, so you build the habit of reasoning about correctness yourself. The interview tools are bare.
• Time yourself to 20 minutes per problem. When you blow the clock, write down why: misread the prompt, wrong structure, or fumbled implementation. The fix is different for each.

How to win the round:

1. Clarify first. Restate the problem in your own words, confirm input types, sizes, and edge cases (empty input, duplicates, negatives, integer overflow). Thirty seconds here prevents ten minutes solving the wrong problem.
2. Think out loud. State your brute-force approach and its complexity, then the optimization and its complexity. Interviewers score your reasoning, not just the final code, so silence costs you even when the code is right.
3. State complexity for time and space before and after you optimize. Say the numbers, do not just imply them.
4. Write clean code: meaningful names, small helper functions, early returns over nested ifs. Messy code that "works" scores worse than clean code at Meta, because readable code is a hiring signal in itself.
5. Test by hand. Dry-run with one real example and one edge case. Find your own bug before the interviewer points it out. That self-correction is one of the strongest positive signals you can send.
6. Watch the clock. Stuck past two or three minutes? Say your fallback plan out loud and keep moving. A working brute force beats a broken "optimal" attempt every time.

5System design (required for E5)#

Meta's design round ("Pirate") is product-focused HLD: design a real feature at Meta scale. You lead the whiteboard; the interviewer probes trade-offs and pushes on the parts you gloss over. Forty-five minutes goes fast, so run a framework instead of free-styling.

A framework that fits Meta:

1. Requirements (5 min). Functional ("users can post, follow, see a ranked feed") and non-functional (scale, latency, availability, consistency). Ask about read/write ratio and daily active users up front. Meta systems are almost always read-heavy at billions scale, so assume reads vastly outnumber writes.
2. Estimate (3 min). Back-of-envelope: QPS, storage per day, bandwidth. For a feed with 2B DAU each reading 20 times a day, that is roughly 460k read QPS average and multiples at peak. A real number shows you think about scale rather than reciting components.
3. API design (3 min). A few endpoints with inputs and outputs, for example getFeed(userId, cursor, limit) returning a page plus a pagination cursor.
4. Data model (5 min). Entities, which store (SQL vs NoSQL vs graph), and why. Meta's social data maps naturally to a graph model (TAO over sharded MySQL is the real-world reference), so name that and explain the fit.
5. High-level architecture (15 min). Clients -> load balancers -> services -> caches -> datastores. Add a CDN for media, a message queue for async work, and an explicit fan-out strategy for feeds.
6. Deep dive (10 min). Pick the hard part and go deep: feed ranking, fan-out-on-write vs fan-out-on-read, cache invalidation, the hot-key problem for celebrity accounts, sharding strategy. This is where E5 is won or lost.
7. Bottlenecks and trade-offs (4 min). Consistency vs availability, cost, failure modes, and how you would monitor and scale under load.

The one trade-off you must be fluent in is feed fan-out.

• Fan-out-on-write (push each post into every follower's feed at post time) makes reads cheap but falls apart for a celebrity with 50M followers.
• Fan-out-on-read (assemble the feed from followed users at read time) is cheaper to write but heavier to read.
• The real answer at Meta scale is hybrid: push for normal users, pull for high-fan-out accounts, merge at read time.
• Say that and explain why, and you are signaling E5.

Classic Meta prompts:

• Design the News Feed, Messenger or WhatsApp chat, Instagram (photo upload plus feed).
• Design "People You May Know," a notification system, live comments on a video.
• Design a URL shortener or rate limiter (phone-screen level), a nearby-places or typeahead search.

What the level expects.

• For E4, expect one design round that may be lighter or lean toward a scoped component.
• For E5, you are expected to drive the conversation, justify trade-offs without being asked, and show you have operated systems in production: caching, monitoring, staged rollout, failure handling, on-call reality.
• An E5 who has clearly debugged a hot-key incident at 3am reads very differently from one reciting a textbook.

6Behavioral and culture fit#

Meta's behavioral round maps to its engineering values. Know these cold and anchor every story to one explicitly.

• Move Fast: ship, iterate, unblock yourself and others, bias to action over waiting for perfect information.
• Focus on Impact: pick the highest-leverage work and measure the outcome in numbers.
• Build Awesome Things / Be Bold: take smart risks, think big, do not play it safe to look safe.
• Be Open: transparent by default, give and take direct feedback, share information rather than hoard it.
• Meta, Metamates, Me: ownership of the mission and your team first, not just your own tasks. The order of those three words is the point.

Build 6-8 STAR stories in advance.

• Cover: a hard technical project you drove, a conflict with a teammate, a failure and what you learned, a time you shipped under pressure, a time you influenced without authority.
• For E5, at least two stories must show scope and leadership: driving cross-team work, mentoring engineers, or setting technical direction others followed.
• If your best stories are all "I wrote great code," you will read as E4 no matter how strong the code was.

One full worked STAR example (Focus on Impact):

• Situation: Our checkout service had a p99 latency of 2.4s, and support tickets about slow payments were rising ~15% month over month.
• Task: As the service owner, I was asked to bring p99 under 800ms within the quarter without a full rewrite.
• Action: I profiled the hot path and found two synchronous calls to a fraud service blocking every request. I made the non-critical call asynchronous, added a 50ms-timeout read-through cache for the fraud scores, and batched the remaining calls. I rolled it out behind a flag at 1% -> 25% -> 100%, watching dashboards at each step and keeping a rollback ready.
• Result: p99 dropped to 610ms, checkout-related tickets fell ~40% in six weeks, and the async pattern was adopted by two sibling teams. I wrote it up in an internal doc so others could reuse it.

Why that example scores.

• It is quantified: 2.4s to 610ms, tickets down 40%. Meta interviewers listen specifically for numbers.
• The decisions are clearly yours: say "I" when it was you and "we" only when it was genuinely the team. A story where your personal call is invisible scores as if you were a passenger.
• Expect follow-ups: "what would you do differently," "how did you convince the sibling teams," "what broke during rollout." Have the second layer of each story ready, because the interviewer will dig.

7Your prep plan#

4-week plan

• Week 1: Patterns refresh. Arrays, strings, hash maps, two pointers, sliding window. 5 Mediums per day, grouped by topic, not random.
• Week 2: Trees, graphs (BFS/DFS/topological sort), heaps, binary search. Start timing every problem to 20 minutes.
• Week 3: System design daily, one prompt a day using the framework. Study feed, chat, and notifications deeply enough to draw them from memory. Draft your 6-8 STAR stories.
• Week 4: Full mock loops (2 coding + 1 design + 1 behavioral) with a peer or a platform. Review every miss and write down the root cause. Rest the day before, do not cram.

2-week plan

• Days 1-4: Meta-tagged Mediums by pattern, 6 per day.
• Days 5-7: Graphs, trees, heaps, binary search. Speed drills, strict 20-minute cap.
• Days 8-10: System design, 5 classic prompts with the framework end to end.
• Days 11-12: Write and rehearse STAR stories out loud, not in your head.
• Days 13-14: Two mock loops, review, rest.

2-day crash plan

• Day 1 AM: Re-solve 10 Meta-frequent Mediums (two-sum variants, number of islands, LCA, merge intervals, top-K). PM: one design prompt (News Feed) end to end, out loud, on a whiteboard.
• Day 2 AM: 5 more Mediums timed to 18 minutes each, and practice narrating while you code. PM: rehearse 4 STAR stories aloud, confirm interview logistics, sleep early.

8Why people get rejected at Meta#

1. Too slow. Solving one problem well but missing the second in a two-problem round reads as "below the bar for speed." This is the single most common coding-round rejection.
2. Silent coding. A correct answer with no narration leaves the interviewer unable to score your reasoning. Communication is explicitly on the scorecard, so silence is a down-vote even when the code compiles.
3. Buggy "done" code. Declaring a solution finished without testing, then having the interviewer find the bug, is a strong negative. Catch it yourself and it becomes a positive.
4. Hand-wavy system design. Naming components without justifying trade-offs, skipping the scale estimate, or never going deep on the hard part. Drawing boxes is not designing.
5. "We" with no "I". Behavioral answers where your personal contribution and decisions are invisible. E5 candidates especially must show they drove outcomes, not that they were nearby when good things happened.
6. No measurable impact. Stories and resume bullets with no numbers. Meta's culture is impact-obsessed, and vague results quietly undercut your level even when the work was real.

9The offer, comp and negotiation#

Meta comp has three parts: base salary, RSUs (vested over 4 years), and an annual bonus tied to company and individual performance.

• RSUs are a large share of total comp at senior levels.
• Meta often front-loads grants or adds refreshers in later years, so the headline number and the year-one cash can differ.

The ranges.

• India: E4 total comp roughly ₹55-90L/yr; E5 roughly ₹90L-₹1.5Cr+/yr, with RSUs a meaningful and growing portion.
• US: E4 total comp roughly $230-320k/yr; E5 roughly $340-450k+/yr (base ~$190-230k, the rest RSUs plus bonus).
• Numbers vary by location, team, market conditions, and your current comp. Treat these as anchors, not promises.

Negotiation tips for Meta:

1. Negotiate the whole package, not just base. Equity and signing bonus have the most room; base sits in a tight band for your level. Ask the recruiter directly about the RSU refresh policy and the vesting schedule.
2. Use competing offers honestly. Meta benchmarks aggressively and will often match or beat a credible competing offer, so share real numbers rather than a bluff they can see through.
3. Push on level. Getting placed at E5 instead of E4 moves your comp far more than haggling a few percent of base. If your loop feedback supports it, make the level case with concrete scope and leadership from your STAR stories. The level conversation is the highest-leverage negotiation you will have.

Want this turned into a personalized, dated study plan around your interview date? Tell us your timeline and current level, and we will map these rounds to a day-by-day schedule you can actually follow.