Meta logo

Meta Hard Interview Questions

11 hard-level practice questions for Meta technical interviews

Meta software engineer interviews cover algorithms, data structures, system design, and coding problems drawn from real interview rounds.

Software Engineer Backend Engineer Frontend Engineer Full Stack Engineer Mobile Engineer Data Engineer Data Scientist ML Engineer DevOps Engineer DevOps Engineer Product Manager SRE Security Engineer Engineering Manager Data Analyst UX/UI Designer QA Engineer
coding Hard Verified Question #1

1. OA[CodeSignal] Cloud File Storage System


Category: Graph coding problem

Question Your task is to implement a simple in-memory cloud storage system that maps objects (files) to their metadata (name, size, etc.). You...

Input: Graph (nodes and edges)
Output: Array
Want to practise this one?
Create a free account to open the full question and practise Meta questions with AI.
Sign up free
coding Hard Verified Question #2

2. OA[CodeSignal] Design Banking System


Category: Graph coding problem

Question Design a banking system that supports account management, transactions, and various financial operations.

Input: Graph (nodes and edges)
Output: Computed result
coding Hard Verified Question #3

3. Minimum Prefix Subset


Category: Tree coding problem

Question Given a list of strings, find the minimum subset of prefixes that can represent the entire input set. A string is "represented" if it...

Input: Array of strings
Output: Integer
coding Hard Verified Question #4

4. OA[CodeSignal] In-Memory Database


Category: Graph coding problem

Description Implement a simplified in-memory database that supports record manipulation with various operations. The system should handle basic...

Input: Graph (nodes and edges)
Output: Array
coding Hard Verified Question #5

5. [CodeSignal] House Segments After Destruction


Category: Array coding problem

Question You are monitoring the building density in a district of houses. The district is represented as a number line, where each house is located...

Input: Array of integers
Output: Array
coding Hard Verified Question #6

6. Expression Simplifier


Category: String coding problem
Given an algebraic expression string containing single lowercase-letter variables, the operators + and -, and parentheses ( and ), simplify...
Input: String
Output: Computed result
coding Hard sliding window #1

1. [AI Enabled Coding] WhatsApp Business Delivery Admission Engine


Scenario


Meta's WhatsApp Business delivery infrastructure needs an auditable admission step before outbound messages enter delivery queues. Implement a batch-replay engine that protects recipients from bursts and enforces business-level delivery budgets; you may use an AI assistant while coding, but must explain and test its output. The limits below are hypothetical interview requirements, not actual WhatsApp policies.

Part 1 — Default delivery safeguards


  • Every message is a map containing string values for id, timestamp, tenant, sender, recipient, campaign, and bytes. timestamp is an integer number of seconds and bytes is the nonnegative payload size, both encoded as strings.

  • Process messages in ascending numeric timestamp order, breaking ties by ascending ASCII id. Return decisions in that order, regardless of input order.

  • Apply payload_size: a message may contain at most 1000 bytes.

  • Apply sender_rate: each (tenant, sender) may admit at most 3 messages in a rolling 60-second window.

  • Apply recipient_rate: each (tenant, recipient) may admit at most 2 messages in a rolling 60-second window.

  • For a message at time t, a window of width w contains previously admitted messages with timestamps in (t - w, t], plus the current message when calculating projected usage. Earlier processed messages at the same timestamp count.

  • Evaluate every rule. Admit the message only if every projected usage is at or below its limit. Rejected messages consume no budget under any rule. Return every violated rule name in ascending ASCII order.

  • Your return type is up to you; the examples use a list of decisions containing id, status (ADMITTED or REJECTED), and violations.


Function signature: evaluate_messages(messages: list[dict[str, str]]) -> candidate_defined

Example 1:


Input:
{
  "messages": [
    {"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"400"},
    {"id":"m2","timestamp":"1","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"600"},
    {"id":"m3","timestamp":"2","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"100"},
    {"id":"m4","timestamp":"3","tenant":"T","sender":"a","recipient":"y","campaign":"C","bytes":"1000"},
    {"id":"m5","timestamp":"4","tenant":"T","sender":"a","recipient":"z","campaign":"C","bytes":"100"},
    {"id":"m6","timestamp":"5","tenant":"T","sender":"b","recipient":"z","campaign":"C","bytes":"1001"}
  ]
}

Output:
[
  {"id":"m1","status":"ADMITTED","violations":[]},
  {"id":"m2","status":"ADMITTED","violations":[]},
  {"id":"m3","status":"REJECTED","violations":["recipient_rate"]},
  {"id":"m4","status":"ADMITTED","violations":[]},
  {"id":"m5","status":"REJECTED","violations":["sender_rate"]},
  {"id":"m6","status":"REJECTED","violations":["payload_size"]}
]

Explanation: m3 would be the third admitted message to recipient x, exceeding 2. Because it is rejected, m4 becomes sender a's third admitted message and is allowed, including its exactly-1000-byte payload. m5 would be sender a's fourth message. m6 exceeds the payload limit by 1 byte.

Part 2 — Configurable overlapping budgets


Other WhatsApp Business teams now need tenant-wide byte budgets and campaign-specific message budgets, with independently configurable windows. Extend the engine without replacing the Part 1 rules. The approach must be flexible enough to support future additions of the same kind without adding a special branch for each new rule.
Discuss how your return type changes before implementing this extension.
  • Accept extra_rules, a list of maps whose keys and values are strings. Each map contains id, group_by, metric, window_seconds, and limit.

  • group_by is a comma-separated list of distinct fields chosen from tenant, sender, recipient, and campaign, with no whitespace. All fields together form the rule's grouping key.

  • metric is either messages, contributing 1 per admitted message, or bytes, contributing the message's payload size. window_seconds is a positive integer string; limit is a nonnegative integer string.

  • Each extra rule applies to every message, independently for each grouping key. Its projected usage is the sum of contributions from prior admitted messages in its window plus the current contribution. A rule fires only when projected usage is strictly greater than its limit.

  • Admission is atomic across the default and extra rules: evaluate every rule against the same previously admitted history, then commit to all applicable histories only if none fires.

  • Provide rejection diagnostics containing each violated rule's rule, numeric projected, and numeric limit, sorted by rule ID. For payload_size, projected usage is simply the current payload size.

  • Also provide batch-wide admitted_totals containing numeric messages and bytes. These totals include all admitted messages in the batch, even if their rolling-window entries later expire.

  • The examples use an object containing decisions and admitted_totals; an equivalent typed representation is acceptable.


Extended signature: evaluate_with_rules(messages: list[dict[str, str]], extra_rules: list[dict[str, str]]) -> candidate_defined

Example 2:


Input:
{
  "messages": [
    {"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"700"},
    {"id":"m2","timestamp":"10","tenant":"T","sender":"b","recipient":"y","campaign":"C","bytes":"600"},
    {"id":"m3","timestamp":"20","tenant":"T","sender":"c","recipient":"z","campaign":"C","bytes":"300"},
    {"id":"m4","timestamp":"30","tenant":"T","sender":"c","recipient":"z","campaign":"D","bytes":"200"},
    {"id":"m5","timestamp":"60","tenant":"T","sender":"d","recipient":"w","campaign":"C","bytes":"700"}
  ],
  "extra_rules": [
    {"id":"tenant_bytes","group_by":"tenant","metric":"bytes","window_seconds":"60","limit":"1500"},
    {"id":"campaign_cap","group_by":"tenant,campaign","metric":"messages","window_seconds":"30","limit":"2"}
  ]
}

Output:
{
  "decisions": [
    {"id":"m1","status":"ADMITTED","violations":[]},
    {"id":"m2","status":"ADMITTED","violations":[]},
    {"id":"m3","status":"REJECTED","violations":[
      {"rule":"campaign_cap","projected":3,"limit":2},
      {"rule":"tenant_bytes","projected":1600,"limit":1500}
    ]},
    {"id":"m4","status":"ADMITTED","violations":[]},
    {"id":"m5","status":"ADMITTED","violations":[]}
  ],
  "admitted_totals":{"messages":4,"bytes":2200}
}

Explanation: After m2, tenant usage is 700 + 600 = 1300 bytes and campaign C has 2 messages. m3 projects 1300 + 300 = 1600 bytes and 3 campaign messages, so both extra rules fire and neither budget changes. m4 belongs to campaign D and raises tenant usage to exactly 1300 + 200 = 1500. At time 60, m1 is excluded by the open left boundary; m5 projects 600 + 200 + 700 = 1500 tenant bytes. Campaign C has no prior admitted message in (30, 60], so its projected count is 1. Batch totals are 4 messages and 700 + 600 + 200 + 700 = 2200 bytes.

Example 3:


Input:
{
  "messages": [
    {"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"500"},
    {"id":"m2","timestamp":"1","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"500"},
    {"id":"m3","timestamp":"2","tenant":"T","sender":"a","recipient":"y","campaign":"D","bytes":"400"},
    {"id":"m4","timestamp":"3","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"200"},
    {"id":"m5","timestamp":"60","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"600"}
  ],
  "extra_rules": [
    {"id":"tenant_bytes","group_by":"tenant","metric":"bytes","window_seconds":"60","limit":"1500"},
    {"id":"campaign_cap","group_by":"tenant,campaign","metric":"messages","window_seconds":"30","limit":"2"}
  ]
}

Output:
{
  "decisions": [
    {"id":"m1","status":"ADMITTED","violations":[]},
    {"id":"m2","status":"ADMITTED","violations":[]},
    {"id":"m3","status":"ADMITTED","violations":[]},
    {"id":"m4","status":"REJECTED","violations":[
      {"rule":"campaign_cap","projected":3,"limit":2},
      {"rule":"recipient_rate","projected":3,"limit":2},
      {"rule":"sender_rate","projected":4,"limit":3},
      {"rule":"tenant_bytes","projected":1600,"limit":1500}
    ]},
    {"id":"m5","status":"ADMITTED","violations":[]}
  ],
  "admitted_totals":{"messages":4,"bytes":2000}
}

Explanation: Before m4, the tenant has 500 + 500 + 400 = 1400 admitted bytes, sender a has 3 admitted messages, recipient x has 2, and campaign C has 2. Therefore m4 simultaneously projects 1600 bytes, 4 sender messages, 3 recipient messages, and 3 campaign messages. At time 60, m1 expires from the 60-second windows and both earlier campaign C messages have expired from its 30-second window. m5 projects 500 + 400 + 600 = 1500 tenant bytes, 3 sender messages, 2 recipient messages, and 1 campaign message, so it is admitted. Batch totals are 4 messages and 500 + 500 + 400 + 600 = 2000 bytes.

Notes:


  • There are at most 100,000 messages and 20 extra rules. Do not rescan the entire admitted history for every decision; explain an amortized bound.

  • Inputs are valid: message IDs are unique, identifiers are nonempty ASCII strings of at most 32 characters, and extra-rule IDs are unique and do not reuse default-rule IDs. Numeric inputs are integers between 0 and 1,000,000,000, except window widths must be positive.

  • Each invocation starts with empty history. This is a deterministic, single-process replay problem, not a distributed concurrency or persistent-storage implementation.
Want to practise this one?
Create a free account to open the full question and practise Meta questions with AI.
Sign up free
coding Hard tree #2

2. Binary Tree Serialization — serialize and deserialize a binary tree

Background: At Meta, efficient data storage and retrieval are essential for features like News Feed and Messenger. Serializing a binary tree allows for easy transfer and storage of tree structures, especially those representing user relationships or posts.
Problem statement: Implement the methods serialize and deserialize that convert a binary tree into a single string representation and back again. The representation must be unique and should correctly reconstruct the original tree structure. You can use any traversal method.
Function/class signature:
  • def serialize(root: Optional[TreeNode]) -> str:

  • def deserialize(data: str) -> Optional[TreeNode]:

Example 1:
  • Input: root = [1,2,3,null,null,4,5]

  • Output: "1,2,3,null,null,4,5"

  • Explanation: The binary tree is represented in a level-order format as a string.

Example 2:
  • Input: root = [1]

  • Output: "1,null"

  • Explanation: A single-node tree is represented correctly.

Constraints:
  • The tree will have between 0 and 10^4 nodes.

  • The node values will be integers in the range [-1000, 1000].

coding Hard graph #3

3. [OA] Graph Traversal — Find shortest path for the Facebook Events navigation

This problem simulates navigation through Facebook Events. Efficient pathfinding is crucial for enhancing user experience in discovering events.
Given an undirected graph represented as an adjacency list, return the shortest path from node start to node end.
Example 1:
Input: edges = [[0, 1], [1, 2], [2, 3]], start = 0, end = 3
Output: [0, 1, 2, 3]
Explanation: The shortest path from node 0 to node 3 is 0 -> 1 -> 2 -> 3.
Example 2:
Input: edges = [[0, 1], [1, 2], [0, 2], [2, 3]], start = 0, end = 3
Output: [0, 2, 3]
Constraints:
  • 1 <= edges.length <= 10^4

  • Each edge is a pair of distinct integers.
coding Hard sliding window #4

4. [OA] Sliding Window — Find the longest substring containing at most two distinct characters for Facebook Messenger

This problem is important for optimizing the chat list experience in the Messenger app. By ensuring quick access to frequently used contacts, we can enhance user engagement.
Given a string s, find the length of the longest substring containing at most two distinct characters.
Example 1:
Input: s = "eceba"
Output: 3
Explanation: The substring is "ece" which its length is 3.
Example 2:
Input: s = "ccaabbb"
Output: 5
Explanation: The substring is "aabbb" which its length is 5.
Constraints:
  • 1 <= s.length <= 10^5

  • s consists of English letters, digits, symbols, and spaces.
system design Hard caching #5

5. [OA] LRU Cache — Implement the caching system for Instagram feed

Instagram relies on providing quick access to user feeds, which requires an efficient cache management system. Design an LRU Cache to ensure optimal performance.
Class LRUCache:
  • LRUCache(int capacity): Initializes the cache with a positive size capacity.

  • int get(int key): Returns the value of the key if the key exists, otherwise returns -1.

  • void put(int key, int value): Update the value of the key if present, or add the key-value pair if not existing. When the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.


Example 1:
Input: LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1); cache.put(3, 3); cache.get(2); cache.put(4, 4); cache.get(1); cache.get(3); cache.get(4);
Output: 1; -1; 3; 4
Constraints:
  • capacity is always positive and will not exceed 1000

  • The operations get and put will always be called with valid keys.

Start practicing Meta questions

Sign up for free to access walkthroughs, AI-generated questions, and more.

Get Started Free