Meta Software Engineer interview

Tests: Sorting-based interval reasoning and careful boundary handling under time pressure.

Approach: Sort by start, then sweep while tracking the current merged interval. For the union variant, the key decision is when a new interval extends the current one versus starts a fresh one - settle the open/closed boundary rule before coding.

Tests: Clean two-pointer bookkeeping and edge cases like leading zeros.

Approach: Walk the word and abbreviation with two pointers, parsing digit runs into a skip count. The classic trap is a leading zero in the number - handle it explicitly and say so.

Tests: Operator-precedence handling and disciplined parsing without running code.

Approach: Process the string with a running number and last operator, pushing to a stack on + and -, and mutating the stack top on * and /. Practice this one until it is mechanical - candidates report fumbling it even after prepping it.

Tests: Level-order traversal and converting a tree to an undirected graph.

Approach: Right side view is BFS taking the last node per level (or DFS right-first). Distance K requires building parent pointers first, then BFS outward from the target - mention both directions of travel before coding.

Tests: Prefix-sum construction and binary search over cumulative weights.

Approach: Build a prefix-sum array, draw a random number in its range, and binary-search for the first prefix exceeding it. The follow-up is usually the binary search itself - be exact about which bound you return.

Tests: Whether you can justify binary search on an unsorted array.

Approach: Compare mid to its neighbor and recurse toward the rising (or falling, for the minimum variant) side. The interviewer wants the invariant argument for why a peak must exist on that side - say it out loud.

Tests: Speed on two well-known easies - the round is about pace and polish.

Approach: Simplify Path is a stack over '/'-split tokens with '..' popping; the stock problem is one pass tracking min price and best profit. Both should take you well under 15 minutes combined with clean code.

Tests: Two staple patterns back to back, with index bookkeeping under a clock.

Approach: Roll the window sum by adding the entering and subtracting the leaving element. For the parentheses problem, mark unmatched indices with a stack in one pass, then rebuild the string.

Tests: Handling a ragged 2D structure efficiently, then a precise in-place algorithm.

Approach: Diagonal Traverse II groups elements by i+j (BFS or bucket by diagonal - avoid the O(rows*cols) grid trap on ragged input). Next Permutation is find-pivot, swap-successor, reverse-suffix; know it cold.

Tests: Code organization that survives changing requirements, under monitoring.

Approach: Read all visible stages before writing stage 1, and put state behind small methods so later stages extend rather than rewrite. Timebox: the last stage is worth attempting even half-finished.

Tests: Problem decomposition, prompting skill, and whether you verify AI output instead of pasting it.

Approach: Skim the file tree and tests first, then use the AI for targeted questions ('what does this function assume about input?') rather than 'fix it'. Narrate your verification - candidates report the AI is prompted to withhold direct bug callouts, and verification is a scored dimension.

Tests: The core Meta problem: read-heavy social feeds, fan-out on write vs read, celebrity hotspots.

Approach: Lead with the fan-out tradeoff and the celebrity-user exception, then feed ranking as a separate service. Meta interviewers reward depth on one component over breadth across ten boxes.

Tests: Scheduled ingestion, change detection, and notification delivery guarantees.

Approach: Separate the crawler/ingester, a price store with change detection, and a notification pipeline. Talk about polling frequency vs freshness cost and deduplicating alerts - that is where the interviewer will push.

Tests: Handling write contention and correctness on a scarce shared resource.

Approach: The heart is seat-hold semantics: reservations with TTL, and how you prevent double-booking under spike load. Name your consistency choice explicitly instead of hand-waving 'a database handles it'.

Tests: Latency budgets, precomputation, and (on the product track) API and client behavior.

Approach: Precompute top-k completions per prefix and serve from memory; discuss update freshness separately. On the product-architecture track, spend real time on the client-server contract - debouncing, API shape, caching on device.

Tests: Directness, empathy, and whether you address friction head-on - core Meta culture signals.

Approach: Pick a real disagreement with substance (technical direction, priorities), show you raised it directly and early, and end with the relationship intact. 'I just complied' and 'they were wrong' both fail.

Tests: Whether you own mistakes without deflecting and turn them into process changes.

Approach: Name the bug and impact plainly, walk the mitigation, then the systemic fix (tests, alerts, rollout gates) you drove afterward. The candidate who has no failure story reads as evasive at Meta.

Tests: Meta's direct-feedback culture: can you hear criticism without defensiveness and change behavior?

Approach: Use feedback that actually stung, show the concrete behavior change, and close the loop with the person who gave it. Generic 'I always welcome feedback' answers are exactly what this question filters out.

Tests: Self-direction in Meta's flat, bottom-up structure - especially decisive for E5.

Approach: Show you created clarity: defined the problem, aligned stakeholders, and shipped without being handed a spec. For E5 loops, scope matters - a cross-team story beats a solo one.