Meta E4 Interview Experience
Product[USA] Meta Onsite Non-AI Coding
SWE Product[USA] Meta AI Coding Round
SWE ProductMeta | Facebook | Technical (Phone) Screen | Mid level Software Engineer (Java)
Mid level Software Engineer (Java)Meta screening
Senior Security Engineer37 more experiences below
Summary
I recently interviewed with Meta for an E4 Product role, navigating through a phone screen and multiple onsite rounds, where I successfully tackled various coding, system design, and behavioral challenges.
Full Experience
My Meta E4 Interview Experience
I recently interviewed with Meta for their Product role at the E4 level and wanted to share my experience across the phone screen and onsite rounds.
Before the phone interview, I completed two assessments:
- A coding assessment with 4 stages
- A work-style assessment
Phone Screen
- Count number of 1s in a given subarray in a large array of 1s and 0s. I was given indices for the start and end of the subarray. I started with a simple linear approach, then optimized it to a prefix-sum solution:
prefix[end] - prefix[start - 1]. Follow-ups included questions on handling digits 0–9 instead of binary, and how to handle cases likestart > end. - Find Lowest Common Ancestor of a Binary Tree. I implemented the standard recursive LCA algorithm and walked through examples. I missed one edge case where
pandqhave the same value, and needed a small hint for the scenario where both references point to the same node.
Overall Phone Screen Feedback was positive: strong coding, clear communication, and fast implementation. Improvements were suggested in clarifying questions and edge-case coverage.
Onsite Rounds
Round 1
- Find first 1 in a sorted binary matrix. I solved this problem cleanly.
- Trapping Rain Water. I solved this problem cleanly.
Round 2 (Design Round)
I was asked to design a concert ticket booking service for a small scale (one venue, many concerts). I discussed requirements, user flows, API design, data model, and bottlenecks. I drove the conversation end-to-end, providing detailed but clear explanations, and moved quickly through the design choices. I also pushed back when needed to clarify assumptions.
Round 3
- Valid Palindrome II.
- Valid Word Abbreviation.
I solved both of these problems without any issues.
Round 4 (Behavioral)
This was a standard behavioral round with questions focused on handling ambiguity, conflict resolution, and using data to drive decisions. It was a straightforward conversation centered around my past experiences, demonstrating ownership, and highlighting collaborative efforts.
Interview Questions (8)
Given a large array of 1s and 0s, and indices for the start and end of a subarray, count the number of 1s within that subarray. Follow-ups included handling digits 0-9 instead of binary, and cases like start > end.
Find the Lowest Common Ancestor (LCA) of two given nodes in a binary tree.
Find the position of the first '1' in a matrix where each row is sorted and contains only 0s and 1s.
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
Design a concert ticket booking service, specifically for a small scale scenario with one venue and multiple concerts. The discussion covered requirements, user flows, API design, data modeling, and identifying bottlenecks.
Given a string s, return true if the s can be palindrome after deleting at most one character from it.
Given a word and an abbreviation, check if the word matches the abbreviation. For example, 'internationalization' can be abbreviated as 'i12n' or 'i5s4n'.
This round involved standard behavioral questions, with a focus on topics such as handling ambiguity, resolving conflicts, and using data to inform decisions. The conversation revolved around past experiences, ownership, and collaboration.
Summary
I interviewed for a SWE Product role at Meta in the USA, facing two coding problems: a binary tree column traversal and a complex problem involving friend request logic for centaurs. I couldn't fully solve the second problem but explained my approach.
Full Experience
I recently had an onsite coding interview at Meta for the SWE Product role in the USA. The interview session included two non-AI coding challenges. The first question was a standard binary tree column traversal problem, which I found quite straightforward. The second problem was more involved: designing friend request logic for mythical creatures called centaurs, based on several age-related rules. I struggled a bit with this one and wasn't able to code up a fully working solution covering all the rules within the given time. However, I made sure to clearly communicate my thought process and approach to the interviewer, detailing how I would tackle the problem. I later revisited the problem myself and realized it's manageable if framed correctly.
Interview Questions (2)
Given a binary tree (NOT BST), print the column traversal from leftmost column to rightmost column. If two nodes are in the "same column", the top most node in that column should appear before the bottom most node.
We are building facebook for mythical creatures called centaurs. Centaurs live much longer than humans and we want to understand the number of friend requests when we launch the app. Here's how centaur friendships work (you will be expected to gather some requirements though b/c the interviewer explained the problem in a confusing way):
- Centaurs younger than 100 can friend other Centaurs younger than 100
- Centaurs older than 100 can friend centaurs that are strictly older, but not younger than 100
- Centaurs older than 100 can friend Centaurs older than x/2 + 7
Given a list of ages, return the number of friend requests. Friend requests for centaurs are directional (eg: just because I friend request you doesn't mean you automatically reciprocate the same)
Summary
I interviewed for a SWE Product role at Meta, participating in an AI coding round. This unique experience involved debugging existing utility functions and implementing a solution for an NP-Complete problem involving word subsets, which I solved but struggled to optimize.
Full Experience
My onsite interview process at Meta for a SWE Product role included an AI coding round, a non-AI coding round, a system design interview, and a behavioral interview. For the AI coding round, I was presented with a coderpad equipped with 'AI Assist' mode, offering lightweight foundation models. I chose Claude Haiku 3.5 and was given a codebase consisting of main.py, test.py, solve.py, utils.py, and a data/ directory.
My first task was to fix two failing unit tests in utils.py, which involved minor logic errors and debugging with print statements. The second task was to implement solve.py, a stubbed function designed to take a list of words and identify a subset meeting a specific property. I leveraged AI Assist to craft a good prompt, which helped me generate working code that passed the provided unit tests. However, my solution for this part was exponential time. When asked to optimize, I struggled to find a more efficient approach, later discovering from the interviewer that it was an NP-Complete problem. This was quite an unforgettable experience, highlighting the practicality of such rounds despite the challenging time complexity question.
Interview Questions (2)
I was given a utils.py file with utility functions, where 2 out of 4 unit tests were failing. The task was to fix these minor logic errors. The coderpad provided 'run code' and 'run tests' buttons for debugging, so no manual tracing was required.
The problem involved implementing a stubbed function in solve.py. This function needed to take a list of words and identify a subset of these words that met a certain, unspecified property. This was later revealed to be an NP-Complete problem.
Preparation Tips
To prepare for the AI coding round, I learned to set aside traditional LeetCode grinding, as it wouldn't be as helpful. Instead, I focused on understanding how to effectively use AI Assist with lightweight foundation models like Claude Haiku, practicing careful prompt crafting. A significant part of my preparation involved working with medium-sized codebases across several files (e.g., main.py, test.py, utility modules), similar to the sample codebase Meta provides. The key was to demonstrate responsible AI usage rather than relying on it as a crutch.
Summary
I recently completed my first technical phone screen at Meta for a Mid-level Software Engineer role, where I was tested on two data structure and algorithm problems.
Full Experience
I just got done with my first technical screen in Meta for a Mid-level Software Engineer position, specifically targeting Java roles. The interview involved two distinct data structure and algorithm questions. I felt prepared for both, and I'm looking forward to the next steps.
Interview Questions (2)
Given the root of a binary tree, find the minimum element present in each level. This problem is similar to a standard level-order traversal, but the objective is to track and return only the minimum value found within each level. A follow-up question was posed: how would one achieve this solution with an O(log n) space complexity?
Implement a `Sorted List Iterator` that operates on a collection of `k` sorted lists (given as a `List>`). The iterator should expose two primary functions:
public boolean hasNext(): Returnstrueif there are more elements to iterate,falseotherwise.public int next(): Returns the next minimum element across all `k` sorted lists.
This problem combines concepts from 'Merge K Sorted Lists' and an iterator design, specifically referencing an Airbnb interview question.
Summary
Applied for the Senior Security Engineer role at Meta in London. The screening process included a few questions related to IAM concepts and a coding problem. The outcome of the interview is pending.
Full Experience
Company: Meta
Location: London
Position : Senior Security Engineer
1. Few Questions related to IAM - RBAC, ABAC
2. Check if a number is strobogrammatic
Interview Questions (2)
Questions related to IAM concepts, specifically focusing on RBAC (Role-Based Access Control) and ABAC (Attribute-Based Access Control). These questions likely covered the principles, use cases, and differences between the two models.
Determine whether a given number is strobogrammatic. A strobogrammatic number is one that appears the same when rotated 180 degrees. Valid digits after rotation are 0, 1, 8, and the pairs 6 and 9, 9 and 6.
Summary
I interviewed for a Software Engineer position at Meta in Bengaluru and was rejected after the phone screen, despite solving both technical questions asked.
Full Experience
I was recently approached by an HR from Meta for a Software Engineer role. During the phone screen round, the interviewer asked me two coding questions. I believe I solved both of them correctly with proper code and logic. Despite my efforts, I unfortunately received a rejection for the Software Engineer role.
Interview Questions (2)
Summary
I interviewed with Meta, navigating through a phone screen and two onsite coding rounds, including a custom BFS problem, and culminating in a system design discussion about an online chess game.
Full Experience
My interview journey with Meta began with a phone screen, where I was presented with LC 408 (Valid Word Abbreviation) and LC 791 (Custom Sort String). The onsite rounds followed. In Coding Round 1, I tackled LC 1650 (Lowest Common Ancestor of a Binary Tree III), where the interviewer specifically delved into the rationale behind the optimal space-efficient solution, and LC 1249 (Minimum Remove to Make Valid Parentheses). Coding Round 2 involved a variation of LC 8 (String to Integer (atoi)) and a challenging custom problem: '0-1-2 BFS on a Grid' to find the minimum cost path. I initially approached it with BFS and a heap, but the interviewer pressed for a solution without a heap, which I couldn't provide within the time limit. The final round was a System Design interview, where I was asked to design a 1v1 online chess game along with a leaderboard.
Interview Questions (7)
You are given an m × n grid. Each cell contains an integer value from {0, 1, 2} representing the cost to enter that cell. You can move up, down, left, or right. Your task is to find the minimum cost required to move from the top-left cell (0, 0) to the bottom-right cell (m-1, n-1). [this is not min of total sum of path]
Example 1:
grid = [
[0, 0, 2],
[0, 1, 1],
[1, 2, 1]
]
Output: 1
Example 2:
grid = [
[0, 0, 2],
[0, 2, 2],
[2, 2, 0]
]
Output: 2
Design an online 1 vs 1 chess game along with a leaderboard system.
Summary
I recently interviewed for an E5 role at Meta in London, which consisted of a comprehensive loop including a screening round, two data structures and algorithms rounds, a behavioral round, and a system design round. I encountered a variety of challenging problems ranging from merging sorted arrays to designing a messaging service like WhatsApp.
Full Experience
Screening Round
My interview process began with a screening round, which featured two questions that I would classify as easy to medium difficulty.
Full Loop Interviews
Following the screening, I moved on to the full loop, which was structured as follows:
1. Behavioral Round
This round focused on my past experiences and how I handled various situations, typical of a behavioral interview.
2. DSA Round 1
In the first data structures and algorithms round, I was presented with two problems:
- One involved determining if a matrix represented as an array was a Toeplitz matrix.
- The other was a problem similar to finding the maximum consecutive ones with some allowed flips.
3. DSA Round 2
The second DSA round also had two questions:
- The first asked me to remove extra parentheses to make a string valid.
- The second was about finding the shortest path in a 1-0 matrix from the top-left to the bottom-right corner.
4. Design Round
The final round was a system design interview where I was asked to design WhatsApp, specifically emphasizing the use of API calls instead of websockets for communication.
Interview Questions (6)
Given an array, determine if it represents a Toeplitz matrix. A matrix is Toeplitz if every diagonal from top-left to bottom-right has the same elements.
A problem similar to finding the maximum number of consecutive ones in a binary array, potentially allowing a certain number of zero flips.
Given a string s of '(' , ')' and lowercase English characters, remove the minimum number of parentheses ( '(' or ')') so that the resulting parentheses string is valid. Return any valid string.
Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. A clear path is a path from the top-left cell (0, 0) to the bottom-right cell (n - 1, n - 1) such that all visited cells are 0 and all adjacent cells in the path are 8-directionally connected.
Design a system similar to WhatsApp, focusing on using API calls for communication rather than websockets.
Summary
I had a tech screen at Meta where the interviewer guided me through two coding problems. While I initially struggled with the problems, I was able to suggest the correct approach for the first one. I'm currently unsure about the outcome due to the significant help I received.
Full Experience
My recent tech screen at Meta was quite an experience. The interviewer was incredibly supportive, guiding me throughout the session. Even though I had prepared extensively with the top 70-75 LeetCode questions, the problems presented were distinct. I initially explored a few approaches that didn't quite work out, but for the first question, I eventually proposed the correct strategy, which involved using prefix sums. The second question was also unique, not following the typical patterns of problems like 2sum or 3sum. Overall, I received a fair bit of assistance from the interviewer, leaving me uncertain about the final outcome, as I understand that naive solutions are generally not sufficient.
Interview Questions (2)
Given an array, return an index for which the sum of the elements to its left is equal to the sum of the elements to its right. For example, in [2,3,4,5], the index 2 is the answer because arr[0]+arr[1] (which is 2+3=5) equals arr[3] (which is 5).
Given an array, find the maximum of two numbers in the array such that these two numbers are not adjacent.
Preparation Tips
I prepared for the interview by studying the top 70-75 LeetCode questions.
Summary
My Meta onsite interview experience in Bangalore, India, involved four rounds: AI-enabled coding, DSA, behavioral, and product architecture design. A key takeaway was the importance of clarifying ambiguous problem statements throughout the process.
Full Experience
I went through a comprehensive onsite interview experience at Meta in Bangalore, India, which consisted of four rounds. The order of these rounds was flexible and depended entirely on panel availability.
Round 1: AI-Enabled Coding Interview (60 minutes)
This round was quite unique. I was given an existing codebase, complete with .h and .cpp files, along with test files. The goal was to assess my problem-solving, code development and understanding, verification and debugging, and technical communication skills. It wasn't about using AI as a crutch, but rather as a tool to demonstrate my coding proficiency more efficiently and in a job-relevant manner. I had to run and execute code using existing data files and/or codebases to work through a coding problem. It felt very different from the standard coding interview format.
Round 2: DSA Round (45 minutes) This round presented two problems. The first problem involved determining if two given rectangles, specified by their coordinates, intersect. If they did, I was asked to return all points of intersection. This problem seemed straightforward initially, but I ended up wasting a significant amount of time on it. The second problem was quite vague and related to graph DFS. The interviewer initially asked me to implement two functions, but after I pressed for a lot of clarifying questions, he revealed that those functions were already implemented, and I only needed to implement a third function. By this point, only 7-8 minutes were left. He asked me to code whatever solution I could, and I managed to code the entire solution to his satisfaction. I realized how crucial it is in Meta interviews to proactively clarify the problem statement myself.
Round 3: Behavioral Round In this round, the interviewer focused on understanding how my skills and experience would benefit Meta and how I approach unfamiliar problems. Key areas of discussion included resolving conflict and embracing ambiguity. No specific coding or design problems were posed here.
Round 4: Product Architecture Round This round, which shouldn't be confused with a typical system design interview, challenged me to design privacy level settings for a user within the Facebook app. The settings included options like "Me," "Public," "Friends," and "Friends of Friends." I had to ask numerous clarifying questions to fully grasp the problem statement. I'm uncertain about my performance in this round, but I attempted to list all functional and non-functional requirements, sketch a high-level architecture diagram, identify key entities, and discuss API aspects. The interviewer rigorously questioned me on the database schema and entity relationships, particularly focusing on the "Friends of Friends" case and potential optimization techniques.
Overall, I found that the questions across all interview rounds were often presented in a very vague and open-ended manner, and candidates are clearly expected to proactively clarify them.
Interview Questions (2)
Given the coordinates of two rectangles, determine if they intersect. If they do, return all the points of intersection.
Design privacy level settings for a particular user for the Facebook app, covering options like 'Me', 'Public', 'Friends', and 'Friends of Friends'.
Summary
I had my first round interview for a SWE II, Product role at Meta, which was a 45-minute session involving two coding problems. I managed to achieve an optimal solution for the first question and a working solution for the second, and I'm currently awaiting feedback.
Full Experience
I recently completed my first round for a SWE II, Product role at Meta, for a US-based position. The interview itself was 45 minutes long, and I was expected to solve two problems. My interviewer was quite chill, and I had a good 5-10 minutes at the end to ask them about their experience working on the Brand Ads Team within Monetization. I felt good about my performance on the first question, as I achieved an optimal solution. However, for the second question, I only managed a working solution. I couldn't come up with a more optimal time or space complexity for the second problem, and I'm hoping my working solution is enough to move me forward in the process.
Interview Questions (2)
Given a string and an ordering (presumably a mapping or an array of indices), shuffle the characters of the string such that the specified ordering is met. I discussed a few edge cases with the interviewer, but the implementation was really straightforward.
You are given an M x N grid where '0' represents safe cells and '1' represents walls. You need to determine the shortest path from the top-left cell (0,0) to the bottom-right cell (M-1, N-1). The shortest path is determined by the least number of steps.
Summary
I recently interviewed with Meta for an E6/E5 role. After a successful phone screen and strong performance in most onsite rounds, I received a downlevel offer for an E5 position and am currently in the team matching phase.
Full Experience
My interview journey with Meta started with a phone screen, which included both a coding and a behavioral segment. For coding, I tackled Merge Two Sorted Arrays and a variant of Time Based Key-Value Store. The interviewer for the latter asked me to implement a treemap from scratch, and I managed to build all core functionalities, excluding tree balancing due to time limits. The behavioral part focused on conflict resolution, with several follow-up questions.
The onsite interviews for the E6 level were quite comprehensive. I had two system design rounds: one for Designing a Price Tracking and Alerting System and another for Designing a Create and Search System for Posts. Unfortunately, I couldn't deep dive into the second system design problem as much as I would have liked.
My coding rounds were intense. In the first coding session, I worked on Count Nodes Equal to Average of Subtree and a variant of Minimum Window Substring, each with a couple of follow-up questions. The second coding round presented Nested List Weight Sum and Find Kth Smallest Element Amongst N Sorted Arrays. I struggled to get to the follow-up for the second problem due to time.
Finally, I had a behavioral interview with 7-8 questions covering aspects like scope, impact, and how I handle conflicts. Overall, I felt that most of my interviews went almost perfectly.
The outcome was a downlevel to E5, and I am now in the team matching phase.
Interview Questions (10)
Merge two given sorted arrays into a single sorted array.
A variant of the Time Based Key-Value Store problem. I was asked to implement a treemap data structure from scratch, including its core functionalities, excluding the tree balancing part.
Behavioral question focused on how I resolve conflicts, followed by several follow-up questions.
Design a system capable of tracking product prices and sending alerts when prices change or meet certain criteria.
Design a system that allows users to create posts and search for existing posts efficiently.
Count the number of nodes in a binary tree where the node's value is equal to the average of the values in its subtree (including the node itself).
A variant of the Minimum Window Substring problem, followed by 1-2 follow-up questions.
Given a nested list of integers, return the sum of all integers in the list weighted by their depth. Each element is either an integer or a list -- whose elements may also be integers or other lists.
Find the kth smallest element among N given sorted arrays, followed by follow-up questions.
A session with 7-8 behavioral questions covering topics such as scope, impact, and conflict resolution.
Summary
I recently completed my Meta E5 interview, which included a screening round, two coding rounds, a system design round focused on infrastructure, and a behavioral round. Despite solving most problems and thoroughly discussing the system design, I have a mixed feeling about the overall outcome.
Full Experience
I recently finished my Meta E5 interview process.
Screening
The screening round consisted of two coding problems:
- Minimum Remove to Make Valid Parentheses
- Valid Palindrome II
Both were straightforward string problems, and my focus was on clean implementation and handling all edge cases effectively.
Onsite Rounds
Coding Round 1
In the first coding round, I tackled two problems:
- Dot Product of Two Large Sparse Vectors: I discussed all possible approaches, including hash map and binary search. Due to time constraints, I implemented the hash map approach.
- Left View and Right View of a Binary Tree: I successfully solved this problem using a Breadth-First Search (BFS) approach.
Although I managed to solve both problems within the allotted time, clearly explained the time and space complexity, and performed complete dry runs, I still have a weird feeling about this particular round.
Coding Round 2
The second coding round also had two problems:
- Move all even numbers to the left (in-place): I used a two-pointer approach for this, as the order of elements didn't matter.
- Basic Calculator II: I walked through both stack-based and an optimized single-pass solution. For the actual implementation, I opted for the without-stack approach for better clarity.
System Design (Infra-focused)
For the system design round, the prompt was to design LeetCode for 50,000 users. I took the lead throughout the discussion, clearly defining the functional and non-functional requirements, sketching out APIs, and detailing the architecture (API Gateway → Queue → Worker → Sandbox → Storage). We delved into aspects like async job handling, container orchestration, and fault recovery.
Cross-questions were also posed, such as "Why DynamoDB over SQL?" and "What happens if a container or worker node fails?" I thoroughly explained retry semantics using SQS and the node re-spawn behavior in detail.
Behavioral
The behavioral round consisted mostly of standard questions. While one of my answers didn’t come out as structured as I had intended, overall I felt this round went acceptably.
Interview Questions (7)
This was a straightforward string problem, focusing on clean implementation and handling edge cases.
This was a straightforward string problem, focusing on clean implementation and handling edge cases.
I explained all possible approaches (hash map vs. binary search) and ended up implementing the hash map approach due to time constraints.
I was able to solve it using BFS.
I solved this problem using a two-pointer approach, noting that the order of numbers didn’t matter.
I walked through both stack-based and optimized single-pass solutions, and implemented the optimized version without a stack for clarity.
I led the conversation end-to-end, clearly defining functional and non-functional requirements, APIs, and the architecture (API Gateway → Queue → Worker → Sandbox → Storage). We also discussed async job handling, container orchestration, and fault recovery.
Summary
I recently interviewed onsite at Meta for an unspecified role, going through four rounds covering data structures, algorithms, system design, and behavioral questions. I believe I performed well, coding and dry running all problems, and am now awaiting the results.
Full Experience
I had my onsite interview at Meta, which consisted of four challenging rounds.
- Round 1 focused on data structures and algorithms. I was asked to implement the left and right view of a binary tree, and then to merge three sorted arrays while also removing any duplicate elements.
- Round 2 was a behavioral round where I answered questions about my past experiences and how I handle various situations.
- Round 3 was a system design interview where I had to design a system for ad recommendations.
- Round 4 involved more coding, specifically implementing a basic calculator that handles only addition and multiplication, and then designing a data structure that supports insert, delete, update, and getRandom operations all in O(1) time.
I was able to code everything and dry-run several examples for each problem. I'm currently waiting for the final results.
Interview Questions (5)
Given a binary tree, I had to implement algorithms to find its left view and its right view. The left view includes the nodes seen when looking from the left side, and the right view includes nodes seen when looking from the right side, typically the first node at each level.
I was given three already sorted arrays and tasked with merging them into a single sorted array. An important constraint was to remove any duplicate elements in the final merged array.
I was asked to design a system that can provide relevant ad recommendations to users. This involved discussing various components like data collection, user profiling, ad selection algorithms, ranking, serving infrastructure, and considerations for scalability and latency.
I needed to implement a basic calculator that could evaluate an expression string involving non-negative integers, addition ('+'), and multiplication ('*') operators. The key was to correctly handle operator precedence (multiplication before addition).
The task was to design a data structure that supports four operations—inserting an element, deleting an element, updating an existing element, and retrieving a random element—all with an average time complexity of O(1).
Summary
I recently interviewed with Meta for a Software Engineer position. Despite successfully solving two coding problems during the technical screen, I later realized a critical error in one of my solutions, which ultimately led to a rejection.
Full Experience
I've been preparing on and off for over a year, constantly trying to get calls from leading companies. Finally, I received an interview invitation from Meta for a Software Engineer role, which felt like a significant breakthrough as it was the first FAANG company to reach out to me after numerous applications. I asked for three weeks to prepare and dedicated that time to solving around 150 Meta-tagged problems.
On the interview day, I faced two coding challenges. The first was 'Missing Elements in Sorted Array'. I managed to solve it, although I felt I struggled a bit with explaining my thought process. The second question was 'All Nodes Distance K in Binary Tree'. I was genuinely happy to see this problem as I was quite familiar with it. I almost made a mistake but caught it during my dry run and corrected it. I left the interview feeling confident that I had performed well and would advance to the next round.
However, a few hours later, a crushing realization hit me: I had completely forgotten to implement a visited set in my BFS approach for the second problem. This oversight rendered my entire solution incorrect. The very next day, I received a rejection email. A small part of me had hoped for a different outcome, but it wasn't meant to be. This experience has left me feeling quite disheartened, especially after dedicating three weeks to intense preparation that now feels wasted. I also acknowledge my weaknesses in LLD/HLD, which have been factors in previous interview failures, and this latest rejection just adds to a streak of disappointments.
Interview Questions (2)
The first coding problem I encountered was titled 'Missing Elements in Sorted Array'. I was tasked with identifying elements that were absent from a given sorted array.
The second problem was 'All Nodes Distance K in Binary Tree'. This involved finding all nodes in a binary tree that are exactly 'K' distance away from a given target node.
Preparation Tips
My preparation involved consistent effort over a year. Specifically for this Meta interview, I dedicated three intensive weeks to solve approximately 150 problems tagged for Meta on LeetCode.
Summary
I interviewed for an E5 (Prod) Engineer role at Meta in the U.S. After navigating through both phone and onsite rounds, I unfortunately received a rejection, which left me feeling quite exhausted.
Full Experience
My interview process for the E5 (Prod) Engineer position at Meta in the U.S. involved two main stages: a phone screen and an onsite loop.
The phone screen included two coding problems:
- Binary Tree Vertical Order Traversal
- Minimum Window Substring
The onsite interviews were quite intensive, covering a range of topics:
- Coding Round 1: Buildings With an Ocean View, with a follow-up on handling views from two sides.
- Coding Round 2: A modified version of Insert Delete GetRandom O(1) - Duplicates allowed, where the
remove()function wouldn't take a value, and the value to be removed had to be random. - Coding Round 3: Power(x,n)
- Coding Round 4: Minimum Remove to Make Valid Parentheses
- System Design: Design Netflix
- Behavioral: A standard behavioral questions round.
I heard back after about a week. Despite my efforts, I was rejected. The process took a lot of my time and energy, and honestly, I'm feeling quite exhausted and low on motivation now. Good luck to others going through it.
Interview Questions (7)
You are given an integer array heights of size n representing the heights of n buildings located from left to right. Return an array of the indices of the buildings that have an ocean view. A building has an ocean view if all the buildings to its right are strictly shorter than it. Follow up: Consider the scenario where you can view from two sides (left and right).
Design a system similar to Netflix.
Summary
I recently interviewed for a Production Engineer role at Meta, encountering both a coding challenge involving file processing and a system troubleshooting scenario. Despite my efforts, I was ultimately rejected.
Full Experience
I recently had a phone screen for the Production Engineer role at Meta. The interview consisted of two main rounds. The coding round involved two questions. One was a difficult 'Battleship board variant' that I don't recall the exact details of, but it was beyond what I had practiced, requiring strong DFS/BFS skills. The second coding question asked me to write a program to read multiple files and identify common words, along with the files they appeared in. The troubleshooting round presented an open-ended scenario: given standard system metrics (I/O, disk, CPU), what additional information would I gather for a frequently crashing site? I felt I performed around 8/10 in coding and 10/10 in troubleshooting. However, the recruiter informed me that my performance wasn't satisfactory in either, which felt disheartening, as if they had already decided not to move forward.
Interview Questions (2)
Multiple files were given, and I had to write a program to read those files and print the common word(s) along with the file(s) they belong to.
If all the standard metrics (I/O, disk, CPU, etc.) are already provided, what additional information would you gather from the system for a site that frequently goes down?
Preparation Tips
My preparation involved thorough practice of DFS and BFS algorithms. However, I found that relying solely on LeetCode's 'Meta' tagged questions was insufficient, as the problems I faced, particularly the file-handling ones, were quite unique and unpredictable. My advice for others would be to expand beyond common tagged questions and focus on a deeper understanding of fundamentals and diverse problem types.
Summary
I successfully cleared the technical screen at Meta for an E4 level position after progressing through an online assessment. The interview primarily focused on two data structures and algorithms problems, and I'm now scheduled for the full onsite loop.
Full Experience
I was initially approached by a recruiter and had a phone screen. Following that, I completed an online assessment which was cloud-based. I managed to progress through all four stages of the OA; although I didn't ace every hidden test in the final stage, my score was sufficient to move forward to the next round. The technical screen for the E4 level was my next step, which I successfully cleared. The interview revolved around two specific coding questions. I have a full onsite loop scheduled in the coming weeks.
Interview Questions (2)
Summary
I interviewed for an E4 position at Meta in London, completing a behavioral round and two coding rounds. My system design interview is scheduled for next week. I felt demotivated after the first coding round due to a challenging question I didn't fully solve optimally.
Full Experience
My interview journey for an E4 role at Meta in London started with a behavioral round where I tackled standard questions, ensuring my answers were backed by real-life examples and could handle follow-up questions effectively.
The first coding round presented two problems. First, I was asked to find the Closest BST Value. After discussing BST properties, I provided and coded an optimal solution. The second question, Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit, was unexpected. I proposed a two-pointer approach, coded it, and dry-ran it. The interviewer seemed satisfied, but post-interview, I discovered the optimal solution involves two deques, which left me feeling a bit disheartened.
In the second coding round, the first problem was to find the Kth Largest Element in an Array. I initially described a brute-force solution and then optimized it using a min-heap. A follow-up explored how the approach would change with many reads and memory constraints. The second problem was Peak Element. I started with a brute-force approach and struggled slightly with explaining the binary search solution before coding the optimal one. A minor bug in my conditions was subtly hinted at by the interviewer during a follow-up.
My System Design round is scheduled for next week, and I will update once it's completed. Overall, the unexpected difficulty in the first coding round's second question has left me quite demotivated given Meta's expectations.
Interview Questions (3)
Find the longest continuous subarray where the absolute difference between any two elements is less than or equal to a given limit. I initially proposed a two-pointer approach, which I explained and coded, and then dry-ran. Although the interviewer seemed satisfied, I later realized the optimal solution requires two deques.
Find the Kth largest element in an unsorted array. I initially gave a brute-force approach, and when asked for optimization, I suggested the min-heap approach. There was a follow-up about how the approach would change if there were many reads and the array could fit in memory.
Find a peak element in an array. A peak element is an element that is strictly greater than its neighbors. I first described a brute-force method. I struggled a bit while explaining the binary search approach. I coded the optimal solution, and the interviewer gave a hint about a minor bug in my conditions through a follow-up question.
Summary
I recently completed my Meta E4 interview in London, which included a behavioral round and two coding rounds, with a system design round pending. I felt somewhat discouraged after encountering an unfamiliar problem in the first coding round, despite performing well in other areas.
Full Experience
I had my E4 interview at Meta in London. The process started with a behavioral round, where I answered standard questions with follow-ups, ensuring to provide real-life examples.
My first coding round featured two problems. The first was on 'Closest BST Value'. I discussed various questions related to BSTs, then presented an optimal approach for this specific problem and successfully coded it. The second question, 'Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit', was completely unexpected. I hadn't seen it before, and it wasn't among the top 100 tagged problems. I proposed a two-pointer approach, explained it thoroughly, wrote the code, and dry-ran it. I even asked the interviewer twice if they were satisfied, and they confirmed yes. However, after the interview, I realized the optimal solution involves two deques, making me question why the interviewer didn't guide me, especially since we finished 5 minutes early. This particular question left me feeling quite discouraged, given Meta's high expectations.
The second coding round also had two questions. For 'Kth Largest Element', I initially presented a brute-force approach and then optimized it using a min-heap. The interviewer then asked a follow-up on how the approach would change for frequent reads with an in-memory array. The second question was 'Peak Element'. I started with a brute-force idea and then moved to the binary search approach, struggling a bit with the explanation. I coded the optimal solution, but there was a minor bug in my conditions, which the interviewer subtly hinted at during a follow-up.
My System Design round is scheduled for next week, so the overall process is still ongoing. The challenge with the second question in the first coding round has certainly made me reflect.
Interview Questions (4)
I was asked a few questions on Binary Search Trees, then specifically this problem. I provided an optimal approach and then coded it up.
This question caught me off guard as I hadn't seen it before. It's not among the top 100 tagged problems. I proposed a two-pointer approach, explained it, wrote the code, and dry-ran it. The interviewer confirmed satisfaction with my solution, but later I realized the optimal solution involves two deques, which I missed.
I initially gave a brute-force approach. When asked for optimization, I suggested using a min-heap. The interviewer followed up on how the approach would change if there were many reads and the array could fit in memory.
I first explained a brute-force approach and then tried to explain the binary search approach, which I struggled with a bit. I coded the optimal solution, and the interviewer hinted at a minor bug in my conditions during a follow-up question.
Preparation Tips
My preparation involved practicing various LeetCode problems. However, encountering a question like 'Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit' that wasn't among commonly tagged problems highlighted the need for more comprehensive preparation beyond just popular questions.
Summary
I recently completed the full interview loop with Meta, which included a technical screening, two coding rounds, a system design discussion on Netflix API, and behavioral questions. My preparation involved focusing on Meta's top 100 questions.
Full Experience
I recently went through the complete interview process for Meta. It began with an HR call, followed by an Online Assessment that covered both technical and behavioral aspects.
The technical screening involved a coding problem described as a 1D Candy Crush variation, for which a link to Max Consecutive Ones III was provided.
The full loop consisted of two intensive coding rounds. In the first coding round, I tackled 'Closest Value to Target in a BST' and Next Permutation. The second coding round presented Sum Root to Leaf Numbers and Simplify Path.
Following the coding rounds, I had a Product Design round where I was challenged to design the Netflix API. Finally, the Behavioral Round covered topics like my proudest project, a situation where I faced pushback, and my approach to unknown technical problems.
Interview Questions (9)
This coding question was described as a 1D Candy Crush variation. A link to Max Consecutive Ones III was provided, suggesting the problem involves finding the longest subarray of 1s in a binary array with the ability to flip at most K zeros.
I was asked to find the closest value to a given target in a Binary Search Tree (BST).
The problem involved implementing the algorithm to find the next lexicographically greater permutation of numbers. A link to the LeetCode problem Next Permutation was provided.
I had to calculate the sum of all numbers formed by traversing root-to-leaf paths in a binary tree, where each path represents a number. A link to the LeetCode problem Sum Root to Leaf Numbers was provided.
The task was to simplify a given Unix-style absolute path. A link to the LeetCode problem Simplify Path was provided.
In the Product Design round, I was tasked with designing the API for Netflix, which involved considering system architecture, scalability, and various functional requirements.
I was asked to discuss my proudest project that I had worked on.
I had to describe a situation where I faced pushback and how I addressed it.
I was asked about my approach when encountering unknown technical problems.
Preparation Tips
My preparation primarily focused on solving the top 100 Meta questions.
Summary
I recently interviewed at Meta for an E5 Software Engineer position and, despite some initial doubts, I successfully passed all rounds and received an offer for an IC5 role.
Full Experience
Phone Screen
My initial phone screen included two coding problems: 'Find local minima' and a 'Valid Palindrome variant.' I made a minor error on the first question, leading to an incorrect answer. Despite this, the interviewer was very gracious and passed me through, which I consider extremely lucky and humbling.
Coding 1
This was my weakest round. I was asked about 'insert-into-a-sorted-circular-linked-list' and 'vertical-order-traversal-of-a-binary-tree.' For the second problem, I had to correct a bug after the interviewer pointed it out. However, I managed to complete both problems within the allotted time. I felt this round was, at best, a 'Lean Hire.'
Coding 2
This was my strongest performance. I tackled 'nested-list-weight-sum' and a 'basic-calculator variant.' I demonstrated great communication, delivered an optimized solution, and had bug-free code. I felt confident this was a 'Strong Hire' round.
System Design
The main problem was designing 'Top K heavy hitters.' I addressed all aspects, but we ran out of time before I could dive deeper into one specific question. I also felt the interviewer might have veered off-topic, and I had to guide the discussion back. Overall, I thought this round was a 'Hire' or 'Lean Hire' for E5.
Behavioral
This round focused on Meta's standard Leadership Principles. The questions were very pointed, and I answered over 25 questions, including follow-ups, in 40 minutes. My examples were all relevant to E5/E6 scope and based on genuine experiences, which helped with the follow-up questions. I strongly believe in being honest in this round as interviewers can discern authenticity.
Overall, I initially expected a reject for E5 or a downlevel to E4 due to my performance in Coding-1 and my mixed feelings about System Design. However, the recruiter contacted me the very next day to confirm an IC5 offer and the next steps for team matching.
Interview Questions (8)
Find a local minimum in an array or matrix.
A variation of the Valid Palindrome problem.
A variation of the Basic Calculator problem series (e.g., I, II, III, IV).
Design a system to find the Top K most frequent items (heavy hitters) from a stream of data.
Behavioral questions centered around Meta's specific Leadership Principles, including targeted follow-ups.
Summary
I successfully passed my phone screen at Meta, solving two LeetCode problems: Minimum Remove to Make Valid Parentheses and Range Sum of BST, even though I had a brief moment of struggle on the second question.
Full Experience
I recently had my phone screen at Meta and passed last week. I'm really glad to share my experience. My interviewer was incredibly nice and chill, which I believe really helped me out, especially when I fumbled a bit in places I shouldn't have. He didn't ask for many follow-ups or questions during my implementation, besides having me run through another example for each problem. I think I was able to pass mainly because my interviewer was cool and understanding.
Interview Questions (2)
For the first question, I was given Minimum Remove to Make Valid Parentheses. I finished this one pretty quickly. I discussed using a stack-based approach but then mentioned I could also achieve an O(1) space solution. I was provided example inputs and outputs, and I did dry runs for a couple of them.
The second question I faced was Range Sum of BST. I almost blanked on this one but thankfully managed to pull myself together. The code I wrote was a bit clunky, but I checked it later, and it passed on LeetCode. I did a dry run of a provided example, getting a bit mixed up in the middle but quickly getting myself back on track.
Summary
I had a screening round at Meta for an E5 position in the USA, where I tackled two coding problems. Despite a slight delay at the start, I was able to discuss my solutions and correct a mistake with a hint from the interviewer.
Full Experience
I recently completed my PS screening round at Meta. The interviewer, a bit stern about my setup, asked me to remove my background blur and close all other applications. This initial hiccup unfortunately consumed the first five minutes of the interview. However, he quickly transitioned, providing his introduction and explaining the interview's structure before diving into the coding challenges.
The first problem involved balancing parentheses in a string. I began by verbally outlining my solution, touching upon a stack-based approach, and then proceeded to code it. I made sure to test with my own example and explain how I'd handle various corner cases. During a dry run, I spotted an error, which the interviewer kindly hinted at, allowing me to correct my solution effectively.
Next, I faced a vertical order traversal problem. Again, I started by verbally explaining my approach, even performing a mental traversal, before coding. My only minor misstep was including a sort that's often needed in LeetCode for same-row/column sorting but wasn't strictly required for their specific test case, which the interviewer gently corrected. I am now awaiting the outcome, expecting to hear back on Monday.
Interview Questions (2)
Given a string containing parentheses (e.g., '))((' or '(())'), determine the minimum number of removals or additions required to make the string balanced.
Implement the vertical order traversal of a binary tree.
Summary
I recently interviewed at Meta for an IC4 position in London and successfully advanced to the team matching phase after completing a phone screen, two coding rounds, system design, and a behavioral interview.
Full Experience
I had a recent interview experience at Meta for an IC4 position in London. The interview process consisted of a phone screen, followed by two coding rounds, a system design interview, and a behavioral interview. I am glad to share that I have received a mail today indicating that they are moving me to the team matching phase. It's a positive step forward, and I'm hopeful for the next stage.
Interview Questions (6)
Given a very large sorted array (length > 1010), the task was to count the distinct elements.
Input: arr[] = {1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 5, 5, 7, 7, 8, 8, 9, 9, 10, 11, 12}
Output: 10
Explanation: The 10 unique elements are: 1, 2, 3, 5, 7, 8, 9, 10, 11, 12
I was asked to implement the right side view of a binary tree, but from leaf to root, and the left side view from root to leaf. After successfully completing this, the interviewer then asked me to also return all the leaf nodes as part of the solution.
Summary
I recently had an interview experience at Meta for an E4 Infra role, where I navigated through screening and onsite rounds, encountering various LeetCode problem variants and a System Design question.
Full Experience
I recently interviewed at Meta for an E4 Infra position. The interview process consisted of a screening round followed by several onsite rounds, including both coding and system design. During the screening, I encountered two coding problems: a variant of 'Best Time to Buy and Sell Stock' and 'Minimum Remove to Make Valid Parentheses'.
For the onsite rounds, I faced several more coding challenges, all of which were variants of well-known LeetCode problems such as 'Diameter of Binary Tree', 'Basic Calculator II' (with an O(1) space constraint), 'Shortest Path in Binary Matrix', and 'Simplify Path'. The System Design round focused on designing a Game Leaderboard.
Interview Questions (7)
A variant of the 'Basic Calculator II' problem, specifically requiring an O(1) space solution. The standard problem involves evaluating a simple arithmetic expression string containing non-negative integers, '+', '-', '*', '/' operators and empty spaces. The variant likely imposes the strict space complexity constraint.
Design a scalable system for a game leaderboard. Consider aspects like storing scores, retrieving top N players, handling updates, and ensuring low latency and high availability for a large number of users and games.
Preparation Tips
I prepared for the coding rounds by focusing on variants of common LeetCode problems, leveraging resources like @CodingWithMinmer's videos. For the System Design interview, I found the HelloInterview Premium subscription to be immensely helpful for a month.
Summary
I successfully passed my Meta E4 On-Site interview for an Infra role in the USA. The process involved a phone screen, system design, two coding rounds, and behavioral interviews, with one behavioral round requiring a redo before I received the offer.
Full Experience
I never thought I would be sharing this, but after passing my Meta E4 On-Site interview for an Infra role, I wanted to give back to the LeetCode community.
Phonescreen
- For the first coding question, I was asked to solve Valid Palindrome 2.
- The second question was Diameter of Binary Tree.
There was an additional question, 1249. Minimum Remove to Make Valid Parentheses, where only the thought process was required, not the code.
Behavioral Interview I
This round covered standard behavioral questions:
- Discussing a project I was most proud of.
- Describing a conflict with a co-worker and its resolution.
- Sharing feedback I had received and how I acted upon it.
System Design I
The core problem was to design a photo messaging app. The interviewer probed deep with follow-up questions:
- Why I chose SQL over NoSQL.
- What consistent hashing is.
- How to scale the system.
- Capacity estimates for the system.
- Explaining the upload and download process for photos/videos to/from S3.
I honestly felt I had bombed this round. The interviewer was very directive, asking deep-dive questions even before I finished the High-Level Design (HLD). Estimations were a specific focus.
Coding Interview I
- Question 1: 50. Pow(x, n). I initially provided an O(N) approach and coded it. The interviewer then pushed for an O(logN) solution. I fumbled a bit and needed some hints but eventually arrived at the recursive O(logN) approach.
- Question 2: Vertical Order Traversal of a Binary Tree. This was more of a discussion round. I had to explain why BFS is often preferred, why not DFS, and how to implement it with DFS. No code was required, and I answered all questions successfully.
Coding Interview II
- Question 1: A variant of 560. Subarray Sum Equals K, asking to return true or false if such a subarray exists. I was also asked to optimize for space/time complexity.
- Question 2: Antidiagonal of a matrix. This round went smoothly with no hiccups.
After these rounds, I had to do a behavioral redo. Fortunately, the questions were the same as the first behavioral round, and this time, the interviewer was much more pleasant. I had also refined my stories, which helped immensely.
I heard back from the recruiter in 4 days after the onsite, and then again in just 1 day after a follow-up, confirming that I had passed the Hiring Committee (HC).
Timeline:
The journey was quite long. The recruiter first reached out in early December, which was when I started studying, as I was also exploring internal opportunities within my current company. I finished the onsite interviews in March, making it a total of about four months of preparation and interviewing.
Interview Questions (11)
Tell me about a project you are most proud of, detailing your contributions and the impact.
Describe a situation where you had a conflict with a co-worker and how you resolved it.
Discuss a piece of feedback you've received, how you reacted, and what you did with it.
Design a system for a photo messaging application, including considerations for uploading, storing, and retrieving photos and videos.
Given the root of a binary tree, return the vertical order traversal of its nodes' values. For each node at (row, col), its left and right children will be at (row + 1, col - 1) and (row + 1, col + 1) respectively. The traversal should be sorted column by column, then by row within each column, and finally by value if multiple nodes are at the same (row, col).
Preparation Tips
For system design, my primary resources were Hello Interview, which was incredibly helpful for understanding the basics and interview strategy, and Alex Xu's System Design books (Part 1 and 2).
For coding interviews, I relied heavily on LeetCode. A huge shoutout goes to CodingWithMinmer on YouTube; their content is fantastic for the community.
Summary
I've shared my insights into Meta's interview style, specifically regarding the 'Custom Sort String' problem (LC791), its common variant, and a crucial optimization follow-up question.
Full Experience
From what I've observed in Meta interviews, they frequently pose the original LeetCode problem 791, 'Custom Sort String'. There's also a minor variant where the order parameter might be presented as a List rather than a string, though this typically doesn't alter the solution significantly. A key aspect of their assessment often comes with a follow-up question: optimizing the character frequency tracking from a HashMap<Character, Integer> to a List<Integer>, which is a good signal if you manage to solve it within time.
Interview Questions (3)
Given two strings order and s. All the characters of order are unique and were sorted in some custom order previously. Permute the characters of s so that they match the order that order was sorted. More specifically, if x occurs before y in order, then x should occur before y in the permuted string. Return any valid permutation of s.
The problem is identical to 'Custom Sort String', but the order parameter is provided as a List<Character> instead of a string. The core logic for sorting characters based on the custom order remains the same, requiring only minor adaptations for handling a list instead of a string.
If the solution for 'Custom Sort String' uses a HashMap<Character, Integer> to store character frequencies, how would you optimize this to use a List<Integer> instead? This typically implies using a fixed-size array (e.g., int[26] for lowercase English letters) to map character ASCII values to array indices for O(1) access.
Preparation Tips
I've detailed my approach and a solution for the original problem, its variant, and the follow-up optimization in my YouTube video. This resource aims to help others prepare effectively for this specific problem pattern often encountered in Meta interviews.
Summary
I had a phone screen with Meta where I was asked two coding problems: LeetCode 88 (Merge Sorted Array) and LeetCode 973 (K Closest Points to Origin). Despite solving both within the allotted time, I was rejected due to insufficient signal.
Full Experience
I had a phone screen with Meta. The interview consisted of two coding questions. The first question was related to LeetCode 88: Merge Sorted Array. A slight twist was that the lengths of the arrays were not explicitly given, only the arrays themselves. I stumbled a bit initially on how to calculate the number of elements in nums1 before realizing it could be derived from nums1.size() - nums2.size(). The interviewer gave me a small hint related to nums2's length, which helped me recover quickly. I solved it with O(n) time and O(1) space complexity.
The second question was LeetCode 973: K Closest Points to Origin. I immediately proposed the priority queue solution and discussed its time complexities. The interviewer then asked if there was a better way, so I mentioned the Quicksort-based (Quickselect) solution and its complexities. I was then asked to code the priority queue solution. During coding, I had some minor bracket-related typos which the interviewer pointed out.
I finished both problems in about 35 minutes. I was hoping for a positive result, but unfortunately, I received an update stating there wasn't enough signal to move forward. I'm quite disappointed in myself because I felt like these were relatively easy medium problems, and I still managed to bomb the phone screen. All the effort I put into preparation felt like it led to a quick rejection.
Interview Questions (2)
Given an array of points points, where points[i] = [xi, yi] represents a point on the X-Y plane, and an integer k, return the k closest points to the origin (0, 0). The distance between two points on the X-Y plane is the Euclidean distance. The answer can be returned in any order, and it's guaranteed to be unique.
Summary
I had a Meta phone screen where I was asked to solve 'K+1th Largest Element' and 'Valid Palindrome'. Despite providing correct solutions and detailed explanations, the interview was frustrating due to vague feedback and ultimately resulted in a rejection.
Full Experience
I recently experienced a Meta phone screen where I was presented with two coding questions. Although I felt well-prepared, the interview left me quite frustrated due to the interviewer's feedback style.
For the first question, 'K+1th Largest Element', I quickly understood the min-heap approach, discussed its complexities, and implemented a solution. I initially made a slight mistake by removing elements before adding new ones but debugged it to ensure elements were added first, then removed if the heap size exceeded K+1. The interviewer probed an edge case with array size 2 and K=2, leading to K+1=3, which I correctly identified as an impossible scenario, suggesting an exception. I implemented this, but the interviewer repeatedly claimed my code had 'bugs' without identifying specific issues, even after I walked through it line by line. This vague feedback was confusing and unsupportive.
The second question was 'Valid Palindrome', requiring me to check if a string is a palindrome while ignoring non-alphanumeric characters and case. I was very familiar with this and quickly implemented a two-pointer solution. Initially, I converted the whole string to lowercase, but the interviewer pointed out the unnecessary space complexity. I adjusted to handle characters in-place, converting to lowercase only when needed. I also refined my code to reduce the number of if conditions. Despite my correct solution and thorough explanation, the interviewer's body language suggested dissatisfaction, which made me feel my efforts weren't being recognized.
Ultimately, I arrived at correct solutions for both problems and was confident in my explanations. However, the lack of clear, actionable feedback and the persistent, unspecific claims of 'bugs' made the experience frustrating. I later received a rejection email, which, though disappointing, is a part of the process. I am now moving on to new opportunities.
Interview Questions (2)
The first question was to find the K+1-th largest element using a min-heap. I was familiar with this problem and quickly explained the approach, discussed complexities, and implemented a solution. Initially, I made a mistake in the order of operations by removing elements from the heap before adding new ones. After debugging line by line, I fixed the issue by ensuring elements were added first and removed only if the heap size exceeded K+1.
The interviewer then asked about an edge case where the array size was 2 and K = 2, making K+1 = 3. I explained that finding the 3rd largest element in an array of size 2 is impossible and suggested throwing an exception. The interviewer agreed with this, so I implemented it. However, they repeatedly insisted there were still "bugs" in my code. Despite running through the code properly and confirming the correct output for all test cases, they claimed I was skipping steps. To address this, I walked through the code line by line with comments, but the interviewer still thought the solution was buggy without identifying specific issues. This left me feeling confused and unsupported.
The second question required checking if a string is a valid palindrome, ignoring digits and any non-letter characters, and considering case insensitivity. I was well-prepared for this question and quickly implemented a two-pointer solution. Initially, I converted the string to lowercase at the start, but the interviewer pointed out that this increased space complexity unnecessarily. I adjusted my code to handle characters in-place by converting them to lowercase only when needed.
The interviewer also suggested reducing the number of if conditions. I addressed this feedback by combining checks into a single condition within the loop. While my solution was correct, and I explained my thought process thoroughly, the interviewer’s body language suggested dissatisfaction, making me feel like my efforts weren’t being fully recognized.
Preparation Tips
I felt well-prepared for the interview, especially for standard data structure and algorithm problems, which allowed me to quickly approach and solve the given questions.
Summary
I completed a screening interview for an E4 position at Meta, successfully solving two coding problems, though I needed to correct a minor error on one. I am currently awaiting feedback.
Full Experience
I recently had my screening interview for an E4 position at Meta. The interview session involved tackling two coding questions. I managed to solve both of them, but during the second problem, the interviewer pointed out a mistake in my code. I promptly identified and corrected the error, completing the solution.
Based on discussions I've seen on LeetCode, I'm not entirely confident about moving forward, and I'm eagerly awaiting their feedback.
Interview Questions (2)
This was a variation of the classic LeetCode Path Sum problem. The standard problem asks to determine if there exists a root-to-leaf path in a binary tree such that its node values add up to a given target sum. While the specific details of the variation weren't provided, it built upon this core concept.
Summary
I successfully navigated the interview process for an E5 Machine Learning Engineer position at Meta in Menlo Park. After two months of dedicated preparation, I received an offer following a phone screen and a full onsite loop.
Full Experience
I approached this as my very first coding interview, and after learning immensely from the LeetCode community, I am now sharing my experience, which I hope will be particularly useful for beginners.
Interview Timeline
- Mid-June: Reached out by HR.
- Mid-July: Phone Screen completed, received a pass email the next day.
- Mid-August: Onsite interviews concluded, received the offer call after 5 business days.
Phone Interview
My phone screen consisted of two standard LeetCode problems:
- Binary Tree Vertical Order Traversal: No variations were present.
- Minimum Remove to Make Valid Parentheses: The interviewer pointed out that my initial solution was not optimal. Luckily, I managed to figure out an optimal approach during the interview.
I solved both questions within 40 minutes.
Coding Interview 1
This round also had two problems, both with minor variations:
- Sum Root to Leaf Numbers: The variation was to sum the actual node values along root-to-leaf paths, rather than numbers formed by digits. I solved this optimally within 10 minutes and provided correct time and space complexity.
- Meeting Rooms II: The variation asked me to return any timestamp that had the maximum overlap, instead of just the maximum number of meeting rooms. I needed a small hint to recognize it as a Meeting Rooms problem and had a bit of a struggle returning the specific timestamp. My solution worked but felt a bit 'ugly'. I solved it in about 30 minutes, providing correct time complexity.
Coding Interview 2
This round also involved two questions, and I felt great about my performance here:
- Minimum Cost Flight Departure and Arrival Problem: This was a problem I had previously dug up from discussions. I solved it optimally within 5 minutes, which reinforced the value of spending hours researching common problems.
- Shortest Path in Binary Matrix: I solved this optimally within 15 minutes. The interviewer was quite satisfied that I completed two questions so quickly.
For the Shortest Path problem, the interviewer followed up with a weighted matrix variation (where each step's weight is the matrix cell's value). I didn't initially realize I could use BFS + Heap (Dijkstra's) and instead coded a DP solution. My DP solution might have had some uncovered corner cases, but the back-and-forth discussion went very well, and I explained my intuition clearly. By the end, I felt relaxed, like I was discussing with a teammate rather than being interviewed.
ML System Design
The topic was something related to harmful content detection. I followed a structured approach, but I was flexible and didn't stick exactly to a 'book' answer. We covered all the essential components and stretch questions within 40 minutes. I believe it's crucial to be adaptable, ready to deep-dive into specific areas the interviewer is interested in, and then pull back to the broader picture when necessary. Interestingly, we didn't use a whiteboard tool at all, which the interviewer was perfectly fine with.
Behavioral Interview
I was asked around 6-7 behavioral questions. Fortunately, all the questions were ones I had prepared for, and the interviewer delved into the details for each of my answers. The interviewer actually ran out of questions after 40 minutes!
Interview Questions (8)
Design a system for detecting harmful content. The interview focused on key components, scalability, and handling various aspects of such a system. I was expected to follow a structured design approach but also be flexible and adaptive to the interviewer's specific areas of interest.
I was asked approximately 6-7 behavioral questions covering various scenarios, typical of Meta's interview process. The interviewer often dug deeper into my responses, seeking more details.
Preparation Tips
Coding Preparation
I had almost no LeetCode experience two months prior to my interviews. From the day HR reached out, I focused intensely on coding preparation:
- Followed NeetCode's roadmap religiously.
- Tackled the top 150 tagged questions on LeetCode.
- Researched and practiced questions from the past 6 months found in LeetCode discussion forums related to Meta interviews.
ML System Design Preparation
My strategy for ML System Design was two-fold:
- I read through the book "Machine Learning System Design Interview" by Ali Aminian and Alex Xu twice.
- Utilized ChatGPT to generate lists of interview questions on specific ML topics, which proved very effective in deepening my understanding.
Behavioral Preparation
For behavioral questions, I searched for common questions and prepared concrete answers in advance, ensuring I could elaborate on my experiences effectively.
General Notes & Tips
- Practice with CoderPad: I highly recommend using CoderPad to practice. Always write down your intuition, preferably with a test example, before starting to code. During my phone screen, I instinctively typed 'class Solution' but was prompted by the interviewer to explain my thoughts thoroughly first.
- Don't Be Afraid to Seek Solutions: As a beginner, it's normal not to solve every new problem independently. My approach was to first check if NeetCode had a solution. If not, I'd consult the Editorial. ChatGPT was also a great tool for explaining complex code.
- Focus on Optimality and Speed for Meta: Meta heavily emphasizes optimal solutions and coding speed. It's incredibly stressful to realize your prepared solution isn't optimal during the interview. ChatGPT can be useful for optimizing code.
- Luck Plays a Role: While preparation is key, acknowledge that luck is a factor. Do your best and let the rest unfold.
Summary
I successfully navigated the Meta London SWE E4 recruitment process, which included a mock interview, phone screening, full-loop interviews, and a follow-up, ultimately securing a hire decision.
Full Experience
My journey through the Meta recruitment process was remarkably smooth, largely thanks to a highly supportive recruiter. After applying on March 17th, I was contacted by the recruiter on April 22nd. We had a mock interview on May 12th where I solved questions like "Move Zeroes" and "Number of Islands". This was followed by a phone screening on May 15th, during which I tackled "Basic Calculator II" and a problem involving merging three sorted arrays without duplicates. I received positive feedback the very next day, May 16th.
The recruiter then set up a call on May 24th to explain the further process. The full-loop interviews took place from June 26th to 27th, comprising two coding rounds, a product design round, and a behavioral round. Unfortunately, I cannot share the exact questions from these rounds due to an NDA. On July 9th, I received an update and was asked for a follow-up coding interview, which I completed on July 30th. This final round also involved two LeetCode Medium questions, though I cannot disclose the specifics. Finally, on August 1st, I received the exciting news of a hire decision.
Interview Questions (4)
Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements. Note that you must do this in-place without making a copy of the array.
Given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), return the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
Given a string s which represents an expression, evaluate this expression and return its integer result. The integer division should truncate toward zero. You may assume that the given expression is always valid. All intermediate results will be in the range [-2^31, 2^31 - 1].
Given three sorted integer arrays, merge them into a single sorted array. The resultant array should not contain any duplicate elements.
Preparation Tips
For my coding rounds, I meticulously prepared using a list of Meta top 350 questions, which included problems from the Cracking Faang YouTube playlist. I also made sure to keep an eye on the LeetCode discuss section for the latest Meta interview questions. I found great value in the detailed and simple solutions provided by channels like Timothy H Chang, Programming Live with Larry, and NeetCodeIO. For system design, I highly recommend Hello Interview (YouTube) and the hellointerview.com website to prepare. I want to emphasize that this is not a sponsored post.
Summary
I recently completed a technical phone screen for an E5 position at Meta in the USA, where I tackled two specific coding challenges after some initial behavioral questions.
Full Experience
I underwent a technical phone screen at Meta for an E5 role in the USA. The interview started with a few standard behavioral questions to get to know my background and approach. Following that, I was given two coding problems to solve. The first problem was 'Binary Tree Vertical Order Traversal', and the second involved merging three sorted lists while also removing any duplicate elements.
Interview Questions (2)
I was asked to implement the 'Binary Tree Vertical Order Traversal' algorithm.
I was tasked with merging three distinct sorted lists into a single sorted list, ensuring that any duplicate values present across the lists were removed in the final output.
Summary
I applied to Meta in January 2024 for an E4 Software Engineer role in London and successfully received an offer after completing multiple technical and behavioral rounds, including a follow-up system design interview.
Full Experience
I applied on Meta's career portal in January 2024 and received a response from HR in the last week of January. I then went through several interview rounds.
Recruiter Screening
This was a ~40-minute telephonic conversation where we discussed my past work experience, tech stack, current projects, deliveries, and impact. I made sure to be well-prepared with everything I had mentioned on my resume.
After this, I qualified for the Technical Screening round.
Technical Screening
I took 1 month to prepare and scheduled this 45-minute round for the last week of February. It started with a 5-minute introduction, followed by 35 minutes of coding, and concluded with 5 minutes for Q&A.
- The first question was Nested List Weight Sum.
- The second was Basic Calculator II.
I successfully provided the optimized solution, dry ran it, covered test cases, and analyzed both time and space complexity for both questions within the allotted time.
I received an email a week later, confirming my qualification for the onsite rounds. I scheduled all of them for the last week of March.
Coding 1
This 45-minute round followed the same structure: 5 minutes introduction, 35 minutes coding, and 5 minutes Q&A.
- The first question was Lowest Common Ancestor of a Binary Tree III.
- The second was LRU Cache.
I got slightly stuck while explaining the mathematical proof of the traversal technique for the first question, but aside from that, everything else proceeded smoothly.
Verdict: Hire
Coding 2
Another 45-minute round with the standard format.
- The first question was: Given an array of integers, return the index of one of the largest elements, chosen uniformly at random.
- The second question was about planning a round trip between two cities with minimum flight cost. I was given two arrays, D[] for departure fees and R[] for return fees, both of equal length with indices corresponding to dates. For example, D: [10, 8, 9, 11, 7] and R: [8, 8, 10, 7, 9], the minimum cost would be D[1] + R[3] = 15.
I was able to present brute force, optimized solutions, dry runs, test cases, and complexity analysis for both questions within the given time.
Verdict: Strong Hire
System Design
This round was 45 minutes, split into 5 minutes introduction, 35 minutes design, and 5 minutes Q&A. The task was to design a component in the Facebook app to show the top k trending hashtags of the last 12 hours, with data refreshing every hour, and different weightages for hashtags from posts, likes, and comments.
I covered functional and non-functional requirements, estimates, APIs, the data model, and a high-level design diagram, along with follow-up questions. However, I wasn't able to delve into the low-level details of components, data aggregation logic, or component interactions.
Verdict: Mixed Signal
Behavioral
This 45-minute round involved standard behavioral questions, which I answered using the STAR format.
Verdict: Strong Hire
Follow-up System Design Round
In mid-April, I received an email stating that an additional system design round was required due to the mixed signal from the previous one. I scheduled this follow-up for mid-May.
The challenge was to design a multiplayer game like chess that could scale up to 1 billion concurrent players. The constraints included no public matching, only matching with friends, and the need for a matching algorithm for friends, as well as immediate ranking board updates after a win/loss.
I thoroughly covered functional and non-functional requirements, estimates, APIs, the data model, a high-level design diagram, trade-offs between NoSQL and SQL, real-time vs. non-real-time ranking boards, and deep-dived into Apache stream processing, MapReduce jobs, and scalability aspects.
Verdict: Strong Hire
I received an offer for the E4 role in the first week of June. After two weeks for team matching and another two for negotiation, I received the final offer letter in the first week of July.
Interview Questions (8)
Given an array of integers, return the index of one of the largest elements, chosen uniformly at random.
Plan a round trip between two cities with minimum flight cost. From the departure city to the destination city, the fees are stored in array D[]. From the destination city to the departure city, the fees are stored in array R[]. Both arrays should have equal length, and the index corresponds to dates. For example, given D: [10, 8, 9, 11, 7] and R: [8, 8, 10, 7, 9], the minimum cost will be D[1] + R[3] = 15.
Design a component in the Facebook app to show the top k trending hashtags of the last 12 hours. This data will be refreshed every hour. Hashtags from posts, likes, and comments will have different weightage.
Design a multiplayer game like chess that can scale up to 1 billion concurrent players. Public matching is not allowed, only matching with friends. There should be a matching algorithm for matching two friends. Also, update the ranking board immediately after a win/loss in a match.
Preparation Tips
I took a dedicated month to prepare for the Technical Screening round. My preparation primarily focused on practicing coding problems similar to those found on LeetCode. For the System Design rounds, I reviewed common design patterns and scalable architecture principles. For behavioral questions, I used the STAR format to structure my answers based on my past experiences.
Summary
I interviewed at Meta for an L4 position, going through multiple rounds covering coding, behavioral, and system design. Despite solving all technical problems optimally and feeling positive about my performance, I was ultimately rejected for not meeting the L4 expectations.
Full Experience
I recently interviewed at Meta for an L4 position, which I secured through a referral. With 3 years of experience and a Master's in CS, I was eager for this opportunity.
Mock Interview
Before the official rounds, I participated in a mock interview which covered two coding questions:
- Move Zeroes to End: I struggled a bit with this one initially but eventually arrived at the correct solution.
- Number of Islands: I successfully implemented a DFS solution.
The feedback from the mock interview was crucial. I was advised to listen more carefully to hints, as I had ignored one given for the first question. Also, for code dry runs, I learned that it's better to choose a new example, especially an edge case, rather than just using the one provided by the interviewer.
Screening Round
My screening round involved two common binary tree problems and a design question:
- Binary Tree Right Side View & Left Side View: I believe I performed well here and didn't make any significant mistakes. The interviewer also confirmed my good performance.
- Design LRU Cache: I felt confident about my solution for this problem too.
Three days after this round, I received positive feedback and moved forward.
Onsite Coding Round 1
This round had two more coding challenges:
- Maximum Sum Subtree in Binary Tree: I initially missed a case where the maximum sum could be negative, but I quickly corrected it after the interviewer's hint.
- Evaluate Expression with Plus and Multiply (e.g., 5*10+3 = 53): I solved this problem without any errors.
Onsite Coding Round 2
My second coding round also featured two problems:
- Subsets (e.g., {A,B,C} --> [{},{A},{B},{C},{A,B},{A,B,C},{B,C}]): I successfully solved this. During my explanation, I briefly thought I had made a mistake, but the interviewer reassured me that my code was correct, and I completed my explanation.
- Valid Word Abbreviation: I solved this optimally. I made a minor mistake with variable naming, which I corrected after the interviewer pointed it out.
For all the coding questions across these rounds, I was able to find optimal solutions and implement them successfully.
Behavioral Interview
This round focused on standard behavioral questions, and it was quite brief, lasting only 25 minutes. The interviewer mentioned beforehand that it wouldn't take the full 45 minutes. We discussed for another 10 minutes afterward. The questions included:
- Challenges in a project
- Strengths and weaknesses
- Conflict with a manager
- How I handle deadlines
- How I handle receiving feedback
- Instances where I took initiative
I felt this round went really well.
System Design
The system design problem was to "Design an ad aggregation system." I believe this round also went smoothly for me.
Despite feeling positive about my performance across all rounds, I unfortunately did not receive an offer. The recruiter informed me that while there were no "red flags," I hadn't quite met the expectations for an L4 level. It was quite devastating to hear the results, especially knowing there's a one-year cooldown period before I can apply again.
Interview Questions (16)
Given an array of numbers, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
Given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), return the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.
Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
Given the root of a binary tree, imagine yourself standing on the left side of it, return the values of the nodes you can see ordered from top to bottom.
Design a data structure that follows the constraints of a Least Recently Used (LRU) cache. Implement the LRUCache class: LRUCache(int capacity) initializes the LRU cache with positive size capacity. int get(int key) Return the value of the key if the key exists, otherwise return -1. void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
Given the root of a binary tree, return the maximum sum of any non-empty subtree. A subtree includes a node and all its descendants.
Implement a function to evaluate a string expression containing only non-negative integers and the '+' and '' operators. Follow standard order of operations (multiplication before addition). For example, '510+3' should evaluate to 53.
Given a set of distinct integers, return all possible subsets (the power set). The solution set must not contain duplicate subsets. Example: {A,B,C} -> [{},{A},{B},{C},{A,B},{A,B,C},{B,C}]
Given a word and an abbreviation, return whether the word matches its abbreviation. A number in the abbreviation represents the number of non-empty characters that are skipped. For example, 'internationalization' can be abbreviated as 'i12iz4n'. The number cannot have leading zeros.
Describe a significant challenge you faced in a project and how you overcame it.
Discuss your greatest strengths and weaknesses.
Describe a time you had a conflict with a manager and how you handled it.
How do you prioritize and manage your workload when facing tight deadlines?
Tell me about a time you received constructive feedback. How did you react and what did you do with it?
Describe a situation where you took initiative and what the outcome was.
Design a system capable of aggregating advertisements from various sources and serving them efficiently to users.
Preparation Tips
My preparation was multi-faceted:
Coding:
- I focused on solving the top 100 Facebook-tagged LeetCode questions.
Behavioral:
- I utilized ChatGPT to generate typical behavioral questions and drafted my answers, tailoring them to my specific experiences.
- I dedicated approximately 10 hours to behavioral preparation, spread over three days.
- Discussing and verifying my answers with a friend proved to be very helpful.
System Design:
- I studied "System Design Vol 1" and "Vol 2".
- I also covered the initial chapters of "Designing Data Intensive Applications."
Summary
I interviewed for an E4 position at Meta and was ultimately rejected. The interview process included a phone screen, two coding rounds, a behavioral round, and a system design round, where I struggled with a mobile-focused design problem.
Full Experience
I decided to give back to the LeetCode community by sharing my interview experience at Meta. The process started with a phone screen, followed by an onsite interview which included two coding rounds, a behavioral round, and a system design round.
Phone Screen Interview:
For the phone screen, the first question I encountered was LRU Cache. I was familiar with this problem and was able to implement the optimal solution using a doubly linked list and a hashmap efficiently. The interviewer noted that since this was a relatively long question, one question would suffice. However, he then asked me another question, which was very similar to Daily Temperatures. For this, I was only asked to explain the solution concept rather than coding it out. I explained my approach, and after this round, I advanced to the onsite interviews.
Onsite Interviews:
Coding Round 1:
Q1: This was a fairly simple question. I was asked to implement a function that, given an array and a window size k, would return the moving average within that window. For example, given [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6]. I found a straightforward solution for this problem.
Q2: The second question was a graph problem, Word Ladder. I knew this problem well and was able to code the solution smoothly.
Coding Round 2:
Q1: This question was similar to Valid Word Abbreviation. It was again very simple, and I completed the code and walked through the solution in about 5 minutes.
Q2: The second problem was similar to Binary Tree Right Side View. This also felt simple to me, and I finished the code and walkthrough very quickly.
Behavioral Round:
This was one of my strongest rounds. The interviewer was very kind and friendly. We discussed some of my complex projects and how I approached and solved the challenges within them.
System Design Round:
This is where I struggled. Despite having prepared extensively for backend system design, I faced a mobile system design question. The interviewer asked me to design a library that, given a URL, downloads files from external sources. He even wrote a definition for one function: func($url, ?= parameters), highlighting the parameters with a question mark. As I asked more clarifying questions, he steered me to focus on the client side, seemingly evaluating my JavaScript abilities, specifically concerning concepts like promises and threads in JavaScript. I continued to answer based on what I believed would be a good design for such a library, and he inquired about the number of threads I would use and what a safe number would be. After the interview, upon further research, I found that the problem was similar to a file downloader library discussed on a proandroiddev blog.
I genuinely didn't know if everyone was expected to handle mobile system design. It was disheartening to be rejected primarily due to a mobile system design problem, especially after putting in significant effort preparing for backend system design. My advice to others is to ensure you prepare for both mobile and backend system design. Once I reviewed the blog post, I realized the question wasn't inherently difficult, but a lack of familiarity with mobile system design can certainly lead to a struggle. Also, it might be beneficial to revise JavaScript concepts; it might help you now or in the future.
I wish everyone the best of luck with their interviews.
Interview Questions (7)
Implement the LRU Cache data structure. It should support the following operations: get and put. get(key) will retrieve the value of the key if it exists, otherwise return -1. put(key, value) will update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
Given an array of numbers and a window size k, calculate and return an array of moving averages for each window. For example, given the array [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6].
Given two words, beginWord and endWord, and a dictionary wordList, return the length of the shortest transformation sequence from beginWord to endWord, such that: Only one letter can be changed at a time. Each transformed word must exist in the wordList. Return 0 if there is no such transformation sequence.
Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
Design a library that, given a URL, downloads files from external sources. The interviewer provided a function signature: func($url, ?= parameters). I was asked to focus on the client-side, including JavaScript concepts like promises and threads, and considerations like the optimal number of threads for downloading files. This problem was similar to a file downloader library discussed on proandroiddev blogs.
Preparation Tips
For system design, I studied Alex Xu's System Design Interview Volume 1 and Volume 2, and completed 'Grokking the System Design Interview'. I also watched some random videos. For coding, my preparation involved extensive practice on LeetCode. Based on my experience, I would advise others to also prepare for mobile system design and to revise JavaScript concepts thoroughly.
Summary
I interviewed for an E4 role at Meta, going through phone screen and multiple onsite rounds. Despite performing well in coding and behavioral rounds, I was ultimately rejected due to my performance in the system design round, which unexpectedly focused on mobile system design.
Full Experience
My interview journey for an E4 position at Meta began with a phone screen. The first question was implementing an LRU Cache. I was familiar with this problem and successfully solved it using an optimal solution involving a doubly linked list and a hashmap. The interviewer, noting the complexity, deemed one question sufficient. However, I was then asked a conceptual question very similar to LeetCode's Daily Temperatures, which I explained without needing to code. This round went well, and I proceeded to the onsite interviews.
The onsite portion had two coding rounds. In Coding Round 1, the first question was quite straightforward: given a window size, calculate the moving average within that window. For example, with [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6]. This was a direct solution. The second question was the classic graph problem, Word Ladder. I knew this one well and coded the solution smoothly.
Coding Round 2 also consisted of two problems. The first was similar to 'Valid Word Abbreviation', which I found very simple and completed the code and walkthrough in about 5 minutes. The second was akin to 'Binary Tree Right Side View', also simple, and I managed the code and walkthrough very quickly.
The Behavioral round was arguably my best. The interviewer was incredibly kind and friendly. We discussed some of my complex projects and how I approached solving the challenges within them.
My struggle came during the System Design round. Despite extensive preparation from sources like Alex Xu (Volumes 1 and 2) and 'Grokking the System Design' (which I completed entirely), along with various videos, I received a mobile system design question rather than a typical backend one. The problem was to design a library that, given a URL, downloads files from external sources. The interviewer even provided a function signature: func($url, ?= parameters). As I asked clarifying questions, it became apparent he wanted me to focus on the client-side, seemingly assessing my JavaScript proficiency, particularly concerning promises and threads. I continued to answer based on what I thought would be a good design for such a library, addressing questions about thread management and safe numbers. After the interview, I researched and found the problem was indeed similar to a Mobile system design file downloader library, as discussed in a blog by ProAndroidDev.
I was genuinely disappointed, as I had dedicated my preparation to backend system design, and the rejection felt largely based on this unfamiliar area. It made me realize that even if you're not expecting it, preparing for mobile system design is crucial, and refreshing JavaScript concepts can be beneficial. Wishing everyone the best of luck in their interviews!
Interview Questions (7)
Implement a Least Recently Used (LRU) cache.
A question very similar to LeetCode's Daily Temperatures problem. I was asked to explain the solution without coding.
Given an array of integers and a window size k, calculate the moving average for each window. For example, if the input is [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6].
Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that: Only one letter can be changed at each step. Each transformed word must exist in the word list.
A question similar to LeetCode's Valid Word Abbreviation problem.
A question similar to LeetCode's Binary Tree Right Side View problem.
Design a client-side library that, given a URL, downloads files from external sources. The interviewer focused on client-side aspects, specifically JavaScript abilities, promises, and threads. Questions included managing the number of threads and determining a safe number.
Preparation Tips
I had done system design preparation from Alex Xu's volumes 1 and 2, and completed 'Grokking the System Design' entirely. I also watched some random videos, but my main focus was on books, specifically for backend system design. Looking back, I realize the importance of preparing for mobile system design as well, and recommend revising JavaScript concepts like promises and threads.
Summary
I interviewed for an E4 position at Meta and was ultimately rejected, primarily due to struggles in the mobile system design round, despite performing well in coding and behavioral interviews.
Full Experience
I interviewed for an E4 position at Meta, starting with a phone screen. I was given the LRU Cache problem, which I solved optimally using a doubly linked list and hashmap. The interviewer indicated that one question was sufficient due to its length. He then gave me a conceptual question very similar to Daily Temperatures, asking only for an explanation of the solution. I cleared this round and proceeded to the onsite interviews.
The onsite consisted of two coding rounds, a behavioral round, and a system design round. In the first coding round, I solved a fairly simple problem to find the moving average within a given window (e.g., [1,2,3,4,5,6,7] k = 3 output [2, 3, 4, 5, 6]), which was a straightforward solution. This was followed by the Word Ladder graph problem, which I knew and coded smoothly.
The second coding round included a simple question similar to Valid Word Abbreviation, which I coded and walked through in about 5 minutes. The second question was similar to Binary Tree Right Side View, which was also simple, and I quickly completed the code and walkthrough.
My behavioral round was one of my best. The interviewer was very kind and friendly, and we spoke about some of my complex projects and how I solved problems within them.
The system design round was where I struggled. I was asked to design a library that, given a URL, downloads files from outside. The interviewer provided a function definition func($url, ?= parameters) and directed me to focus on the client-side, seemingly judging my JavaScript abilities, specifically focusing on concepts like promises and threads. I kept answering based on what I thought would be a good design for such a library, and he asked questions about thread counts and safe numbers. Upon doing some research afterward, I found the problem was similar to a mobile system design exercise. Despite my extensive preparation in backend system design, this mobile-focused problem caught me off guard. I was ultimately rejected, and I believe my performance in this round was the primary reason for the outcome. I was fairly disappointed as I had prepared extensively for backend system design.
Interview Questions (8)
In the first onsite coding round, I was asked a fairly simple question: given a window size, get the moving average within that window and output it. For example, if the input is [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6].
I was asked a problem similar to Binary Tree Right Side View, which was also simple. I completed the code and walkthrough very quickly.
This was one of my best rounds. The interviewer was very kind and friendly. We discussed some of my complex projects and how I solved problems within them.
I was asked to design a library that, given a URL, downloads files from outside. The interviewer provided a function definition func($url, ?= parameters) and guided me to focus on the client-side, seemingly assessing my JavaScript abilities, specifically around promises and threads. I was asked questions about the number of threads to use and what constitutes a safe number. I later found that the problem was similar to a mobile system design exercise.
Preparation Tips
My preparation for system design primarily focused on backend concepts. I studied Alex Xu's System Design books (Volume 1 and 2) and completed 'Grokking the System Design Interview.' I also watched some random videos, but my main focus was on these books.
My advice to everyone is to make sure you prepare for mobile system design as well, in addition to regular backend system design. If you have no clue what mobile system design looks like, the struggle can be natural. Also, make sure to revise your JavaScript concepts, as that might or might not help, but hopefully, it will be useful.
Summary
I interviewed for an E4 position at Meta and was ultimately rejected. While I performed well in the coding and behavioral rounds, my lack of preparation for mobile system design questions led to a struggle in that crucial round.
Full Experience
I wanted to share my interview experience with the LeetCode community.
Phone Screen Interview:
The first question was LRU Cache. I was familiar with this problem and managed to solve it with the optimal solution using a doubly linked list and a hashmap. The interviewer mentioned that since it's a long question, one problem would suffice. However, they then asked me another question, very similar to Daily Temperatures. For this, I only had to explain the solution, not code it. After explaining, I proceeded to the onsite rounds.
Onsite Interview:
Coding Round 1:
The first question was quite simple: given a window size, get the moving average within that window and output it. For example, with an input like [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6]. I found this to be a straightforward solution. The second question was a graph problem, Word Ladder. I knew this problem and coded the solution smoothly.
Coding Round 2:
The first question was similar to Valid Word Abbreviation. Again, it was very simple; I coded it and walked through the solution in about 5 minutes. The second question was similar to Binary Tree Right Side View, also straightforward. I quickly coded and walked through this solution too.
Behavioral Round:
This round was one of my best. The interviewer was very kind and friendly. We discussed some of my complex projects and how I approached solving the problems within them.
System Design Round:
This is where I struggled significantly. I had prepared system design primarily from Alex Xu's volumes 1 and 2, Grokking the System Design, and some random videos, with a strong focus on backend system design. The question I received was more akin to mobile system design than a typical backend one: "Design a library that, given a URL, downloads files from an external source." The interviewer provided a function definition func($url, ?= parameters) and indicated optional parameters. As I asked more clarifying questions, he directed me to focus on the client-side aspects, and it seemed he was evaluating my JavaScript abilities, particularly concepts like promises and threads in JavaScript. Despite this, I tried to answer based on what I believed would be a good design for such a library, discussing aspects like the number of threads. Later, upon researching, I found the problem to be similar to a mobile system design exercise for a file downloader library. I was quite disappointed, as I had put in a lot of effort preparing for backend system design, only to be rejected due to a mobile-focused question I hadn't prepared for.
Interview Questions (7)
I was asked to design and implement an LRU Cache. The optimal solution requires using a doubly linked list and a hashmap to achieve O(1) time complexity for both get and put operations.
I was presented with a problem very similar to LeetCode's Daily Temperatures. The goal is to return an array answer such that answer[i] is the number of days you have to wait after the i-th day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.
Given an array of integers and a window size k, calculate the moving average for each window. For example, if the input is [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6].
I was given the Word Ladder problem. The task is to find the length of the shortest transformation sequence from a beginWord to an endWord, such that only one letter can be changed at each step, and each transformed word must exist in the given wordList.
I encountered a problem similar to LeetCode's Valid Word Abbreviation. The question involves determining if a string can be abbreviated to a given abbreviation, where numbers in the abbreviation represent consecutive characters to be skipped.
I was asked a question similar to the Binary Tree Right Side View problem. The goal is to imagine standing on the right side of a binary tree and return the values of the nodes you can see ordered from top to bottom.
I was tasked with designing a client-side library capable of downloading files from a given URL. The interviewer guided me to focus on client-side aspects, particularly JavaScript concepts like promises and threading models. The problem was later identified as being similar to a mobile system design exercise for a file downloader library.
Preparation Tips
For coding, I consistently used LeetCode to practice a wide range of problems across various data structures and algorithms.
For system design, I prepared diligently using Alex Xu's volumes 1 and 2, and I also went through the entire Grokking the System Design book. Additionally, I watched several random videos on system design topics. My preparation, however, was heavily focused on backend system design principles and patterns, which left me underprepared for the mobile-specific system design question I encountered.
Summary
I successfully navigated the Meta E4 phone screen and onsite interviews, ultimately receiving an offer after a two-month intensive LeetCode preparation period. The whole process took about three months due to holiday delays.
Full Experience
I wanted to share my interview experience with Meta, where I ultimately received an E4 offer. The entire process took about two months of dedicated LeetCode grinding, extending to three months total due to holiday season delays. It's truly beneficial to start preparing early!
The interview process unfolded as follows:
Phone Screen:
During this round, I was given a problem where I had to merge a list of 'n' intervals and return the optimized result. There was also a follow-up question that involved 'k' interval lists.
Onsite:
- Coding Round 1: This was quite unique. The interviewer presented a problem involving a graph of friend relationships, and I was asked to optimize my solution.
- Coding Round 2: I encountered a variant of the LeetCode problem 'Simplify Path' and also a variant of 'Nested List Weight Sum'.
- Product Architecture: For this round, I was tasked with designing a ticket buying application, similar to Ticketmaster. I focused on API and Database Modeling rather than going into deep scalability discussions, as that was the interviewer's preference. I made sure to lead the conversation and document my design notes.
- Behavioral Round: The interviewer asked a number of classic behavioral questions. These included inquiries about projects I'm proud of, how I handle conflict resolution, difficulties I've faced with teammates, and my approach to project prioritization.
Interview Questions (5)
Given a list of 'n' intervals, I was asked to merge them and return the optimized result. There was also a follow-up question involving 'k' interval lists.
I was presented with a variant of the 'Simplify Path' LeetCode problem.
I worked on a variant of the 'Nested List Weight Sum' LeetCode problem.
I was tasked with designing a version of a ticket buying application, akin to Ticketmaster. The key focus was on API design and Database Modeling, rather than extensive scalability discussions.
I was asked several classic behavioral questions, including topics like projects I'm proud of, how I handle conflict resolution, challenges faced with teammates, and my strategies for project prioritization.
Preparation Tips
My preparation involved a rigorous two-month LeetCode grind. My advice is to prepare early. I found it helpful to maintain a spreadsheet of all the LeetCode questions I completed, along with their solutions, for easy review. I also recommend practicing questions specifically tagged for the target company, as they can combine various problem types. Moreover, having a strong grasp of writing clean, readable code is crucial.
Summary
I recently interviewed at Meta for an onsite role and received a rejection, primarily due to my struggle with a mobile system design question during the final round, despite performing well in the coding and behavioral interviews.
Full Experience
Time to give back to the LeetCode community! My interview process at Meta consisted of a phone screen and an onsite round.
1. Phone Screen Interview
I was given LRU Cache. I had seen this question before and was able to solve it with the optimal solution using a doubly linked list and a hashmap. The interviewer mentioned that since it's a long question, one problem was enough. However, he then asked me another question, which was very similar to Daily Temperatures. For this one, I just had to explain the solution and didn't need to worry about coding. After explaining, I moved on to the onsite round.2. Onsite Interviews
Coding Round 1:
Q1: This was a fairly simple question. I was asked to implement a moving average within a given window size. For example, given [1,2,3,4,5,6,7] and k = 3, the output should be [2, 3, 4, 5, 6]. It was a straightforward sliding window solution.
Q2: The next question was a graph problem: Word Ladder. I was familiar with this problem and coded the solution smoothly.
Coding Round 2:
Q1: This was similar to Valid Word Abbreviation. It was very simple, and I managed to code and walk through the solution in about 5 minutes.
Q2: The second question was similar to Binary Tree Right Side View. Again, it was simple, and I quickly completed the code and walkthrough.
Behavioral Round:
This was one of my best rounds. The interviewer was very kind and friendly. We discussed some of my complex projects and how I approached solving problems in them.System Design Round:
This is where I truly struggled. I had prepared system design using various sources, mainly focusing on backend systems. The question I received was more of a mobile system design problem than a typical backend one. I was asked to design a library that, given a URL, downloads files from an external source. The interviewer had written a function definition:func($url, ?= parameters) and emphasized the parameters with a question mark. As I asked more clarifying questions, he steered me towards focusing on the client side and seemed to be evaluating my JavaScript abilities, specifically concepts like promises and threads in JavaScript.
Nevertheless, I tried my best to answer according to what I believed would be a good design for such a library. He asked follow-up questions about the number of threads I would use and what a safe number would be. Upon doing some research later, I found that the problem was similar to the concepts discussed in this article: Mobile System Design Exercise: File Downloader Library.
I genuinely don't know whether everyone is expected to be proficient in mobile system design, but interviews don't come with excuses. I was quite disappointed, having put in all the effort for backend system design, only to be rejected based on my performance in mobile system design. If you're preparing, make sure to cover both mobile and backend system design. Also, it might be beneficial to revise your JavaScript concepts.
Interview Questions (7)
Design and implement a data structure for a Least Recently Used (LRU) cache. It should support the following operations: get and put. get(key) will retrieve the value of the key if it exists, otherwise return -1. put(key, value) will insert or update the value. If the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.
Given an array of integers temperatures representing the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead. The problem was very similar to this concept.
Given a window size, calculate the moving average of elements within that window as new elements arrive. For example, given the stream [1,2,3,4,5,6,7] and a window size k = 3, the output should be [2, 3, 4, 5, 6].
Given two words, beginWord and endWord, and a dictionary wordList, return the number of words in the shortest transformation sequence from beginWord to endWord, such that: 1. Only one letter can be changed at each step. 2. Each transformed word must exist in the wordList. If there is no such sequence, return 0.
Given a word and an abbreviation, check if the word matches the abbreviation. An abbreviation can be formed by replacing a contiguous non-empty substring of a word with its length. For example, 'internationalization' can be abbreviated as 'i12n', 'i5al', etc. This question was similar to the problem described.
Design a client-side library that, given a URL, downloads files from an external source. The interviewer provided a function signature: func($url, ?= parameters). The discussion focused heavily on client-side aspects and JavaScript concepts like promises and threads. The problem was similar to the concepts discussed in this article: Mobile System Design Exercise: File Downloader Library.
Preparation Tips
My preparation for system design included:
- Reading Alex Xu's System Design Interview (Volume 1 and Volume 2).
- Completing 'Grokking the System Design' book.
- Watching various random videos.