Meta Interview Questions

What Meta interviews focus on

Common Meta interview questions

• Given an array of intervals, merge overlapping intervals.
  What a strong answer covers

  • Sort intervals by start time
  • Iterate and merge if overlap (current start <= previous end)
  • Update end as max of ends
  • O(n log n) due to sorting, O(n) space for result
  • Edge case: empty array

  View a sample answer

  To merge overlapping intervals, first sort the intervals by their start time. Then initialize a result list with the first interval. Iterate through the sorted intervals; for each interval, if its start is less than or equal to the last interval's end in result, merge by updating the last interval's end to the max of the two ends. Otherwise, add the interval as a new entry. This greedy approach works because sorting ensures we only need to check adjacency. Complexity is O(n log n) due to sorting and O(n) space for storing the result. A common pitfall is forgetting to sort, leading to incorrect merging for unsorted input. A follow-up might ask for in-place merging, requiring shifting within the array.

  def merge_intervals(intervals):
      if not intervals:
          return []
      # Sort by start time
      intervals.sort(key=lambda x: x[0])
      merged = [intervals[0]]
      for start, end in intervals[1:]:
          last_start, last_end = merged[-1]
          if start <= last_end:
              # Overlap, merge
              merged[-1][1] = max(last_end, end)
          else:
              merged.append([start, end])
      return merged

• Design a distributed chat system like WhatsApp.
  What a strong answer covers

  • Clients connect via persistent WebSocket/HTTP long-polling
  • Chat servers maintain user connection mappings
  • Message delivery: store-and-forward with sequencing
  • Scaling: shard by user ID, use message queues (Kafka)
  • Offline delivery: push notifications and sync on reconnect

  View a sample answer

  Designing a distributed chat system like WhatsApp requires high availability, low latency, and ordering guarantees. Clients maintain persistent connections (WebSocket) to chat servers. Each chat server holds an in-memory mapping of connected users. Messages are sent via a REST-like API or direct WebSocket. To ensure ordering, each user has a sequence number. Messages are first written to a distributed log (e.g., Kafka) partitioned by conversation ID to guarantee ordering per conversation. A background service consumes the log and pushes messages to online recipients via their chat server. For offline users, messages are stored in a database (e.g., Cassandra) and a push notification service (APNS/FCM) alerts them. When the user reconnects, they sync missed messages via a last-seen timestamp. To scale, chat servers are added behind a load balancer; user connections are sticky based on user ID. A key bottleneck is the message fan-out for large group chats; this can be mitigated by splitting groups into smaller subgroups or using a separate fan-out service. Overall architecture: client -> load balancer -> chat server -> message queue -> delivery service -> database

• Tell me about a time you had a disagreement with a colleague. How did you resolve it?
  What a strong answer covers

  • STAR method: Situation, Task, Action, Result
  • Focus on technical disagreement, not personal
  • Emphasize data-driven resolution
  • Concrete example: implementation approach vs tradeoffs
  • Result: better solution through collaboration

  View a sample answer

  In a previous role, my colleague and I disagreed on the caching strategy for a high-traffic API. I advocated for write-through cache to ensure data consistency, while he preferred write-behind for lower latency. We each had valid concerns. I proposed a meeting where we outlined our arguments with data: we estimated peak write loads and measured read-to-write ratio. After analyzing, we realized that write-through would cause unacceptable latency for writes, while write-behind risked data loss. We decided to implement a hybrid: write-through for critical data and write-behind with periodic consistency checks for non-critical. We paired to implement it and performance improved by 30%. This experience taught me to approach disagreements with openness and data, leading to a better outcome.

• Given a list of words, return the group of anagrams.
  What a strong answer covers

  • Use hash map with sorted string as key
  • Count characters instead of sorting for O(n*k) time
  • Group by character count signature
  • Output list of groups
  • Edge case: empty input, case sensitivity

  View a sample answer

  To group anagrams, we can use a dictionary mapping a signature to a list of words. A straightforward approach sorts each word and uses the sorted string as the key; sorting is O(k log k) per word, total O(n*k log k). A more efficient method uses character count as key: for each word, create a tuple of 26 counts (for lowercase letters) and use that as the key. This reduces to O(n*k) time with O(n*k) space for the dictionary. The output is the list of values from the dictionary. A common pitfall is ignoring case or non-alphabetic characters; clarifying constraints is important. Follow-up: if words are very long, the count array method is preferred. The space complexity is O(n*k) in the worst case, but we can optimize by using a smaller signature (e.g., frequency string).

  def group_anagrams(strs):
      from collections import defaultdict
      anagram_map = defaultdict(list)
      for s in strs:
          # Create count array of 26 zeros
          count = [0] * 26
          for ch in s:
              count[ord(ch) - ord('a')] += 1
          # Use tuple as key (hashable)
          key = tuple(count)
          anagram_map[key].append(s)
      return list(anagram_map.values())

• How would you redesign Facebook's photo sharing feature to increase engagement?
  What a strong answer covers

  • Identify pain points: permission control, discovery, sharing friction
  • Targeted improvements: shared albums, AI tagging, Stories integration
  • Engagement metrics: shares, comments, opens, time spent
  • Monetization: print orders, ads in album suggestions
  • Privacy: granular permissions, temporary access

  View a sample answer

  To redesign Facebook's photo sharing feature to increase engagement, first analyze current barriers: limited group sharing, poor discovery, and low reuse. I would propose: 1) Smart albums that auto-group photos by event or people using AI facial recognition, making it easier to find and share. 2) Collaborative albums where friends can add photos to a shared space, increasing contribution. 3) Seamless integration with Stories and Memories to surface shared photos later, driving re-engagement. 4) Commenting directly on photos within albums (not just posts) to spark conversations. 5) Simplified privacy settings per album with options like 'view only' or 'add photos' to encourage sharing without overexposure. Potential metrics: increase in daily photo uploads, album creation, and social interactions per photo. A key risk is user privacy concerns with AI tagging; thus explicit opt-in is needed. Scaling: photos stored in CDN, metadata in graph database, and notifications via push.

• Find the longest increasing subsequence in an array.
  What a strong answer covers

  • Dynamic programming O(n^2) classic, patience sorting O(n log n)
  • DP: dp[i] = 1 + max dp[j] for j < i and arr[j] < arr[i]
  • Patience sorting: maintain piles of decreasing tops, binary search
  • Space O(n) for DP, O(n) for patience
  • Edge case: empty array returns 0

  View a sample answer

  The longest increasing subsequence (LIS) can be solved with dynamic programming in O(n^2) time and O(n) space: dp[i] is the length of LIS ending at index i, and we iterate j < i to find max. For an efficient O(n log n) solution, we use patience sorting: maintain an array 'tails' where tails[i] is the smallest possible tail of an increasing subsequence of length i+1. For each element, binary search in tails to find the first position where tails[pos] >= element, and update. The length of tails at the end is the LIS length. This is optimal. A common pitfall is confusing subsequence vs subarray (must be non-contiguous). Follow-up: if strictly increasing condition not required, adjust comparisons.

• Describe a time you made a mistake and how you handled it.
  What a strong answer covers

  • STAR method: Situation, Task, Action, Result
  • Honest mistake with concrete impact
  • Ownership: admit error, fix, and prevent recurrence
  • Example: production bug, data loss, missed deadline
  • Result: improved process or trust

  View a sample answer

  Early in my career, I mistakenly pushed a configuration change that accidentally deleted user sessions in a staging environment, causing downtime for a QA team. I immediately reverted the change, notified the QA team, and apologized. I then analyzed the root cause: I had bypassed code review for a quick fix. To prevent recurrence, I advocated for mandatory code reviews for configuration changes and added a pre-commit hook to validate syntax. I also set up a sandbox for testing configs. The result was a strengthened change management process, and the team became more cautious. This taught me the importance of process discipline even for small changes.

• Design a news feed ranking algorithm.
  What a strong answer covers

  • User relevance: personalized ranking based on interactions
  • Features: recency, affinity, content type, engagement signals
  • Machine learning: pointwise or pairwise ranking models
  • Data pipeline: real-time features with batch training
  • System components: feature store, model serving, candidate generation

  View a sample answer

  Designing a news feed ranking algorithm requires combining user personalization with content quality. First, candidate generation: retrieve posts from friends, pages, and groups the user follows, filtered by freshness. Then rank candidates using a machine learning model, typically a gradient boosted tree or neural network trained on engagement signals (click-through rate, time spent, likes, shares, comments). Features include: recency (decay function), affinity score between user and content creator (e.g., interaction frequency), content type (video vs text), and past engagement with similar content. The model can be trained pointwise (predict engagement likelihood) or pairwise (predict ordering). To handle real-time updates, a low-latency serving stack with a feature store (e.g., Redis) is used. A key bottleneck is personalization at scale; solutions include using approximate nearest neighbor for candidate retrieval and caching model predictions. Also, incorporate diversity constraints to avoid homogeneous feed. The system must update models periodically (e.g., daily) with new user interactions. Metrics: user session length, engagement rate, and retention. A common pitfall is over-optimizing for clicks, leading to clickbait; thus include explicit negative feedback signals.

Tips to prepare

• Master depth-first and breadth-first search, as tree/graph problems are very common.
• Practice system design within 45 minutes, focusing on trade-offs and scaling.
• Prepare three to five STAR stories that highlight leadership, impact, and conflict resolution.
• Thoroughly understand Meta's leadership principles and align your experiences with them.
• Practice coding on a whiteboard or plain text editor to simulate the interview environment without syntax highlighting.

Frequently asked