Google Engineering Manager (EM) Interview Guide
Read our guide on what to expect in the Google interview and how to prepare.Google engineers solve some of the most challenging technical problems out there, and they do it with style. What’s their secret? Access to world-class resources? A carefully-curated culture fostering innovation? Sure. But leadership plays a big role too. Enter Google’s Engineering Managers (EM).
EMs at Google don’t get to offload all the technical work to their teams. They’re expected to be technical masters, willing to roll up their sleeves to deliver results. They’re also expected to be exceptional leaders - uniting brilliant, non-conformist engineers around a common goal.
It’s a hard job. But if you’re up to it, you’ll have a correspondingly large impact. The products you’ll work on will affect millions if not billions of people, and your solutions will pave the way for others.
If all this sounds exciting, we’ve got just the resource you need to ace the interview. We’ll cover the interview loop, prep for both technical and behavioral questions, and offer some tips and strategies. Let’s get started.
Interview Process
Typically, there are 2-3 rounds of interviews. Because Google is highly competitive and the “team matching” process happens after interviews themselves, the loop can take many weeks or even months.
Recruiter Phone Screen
If you’ve been referred to Google or were contacted directly, this call will be short and sweet. The recruiter will typically make sure you are who you say you are and confirm mutual fit with a few basic behavioral questions, but you won’t get in-depth questions. Instead, you’ll cover the basics of the role and what to expect beginning with the technical screen.
Technical Phone Screen
Now the real work begins. Google’s phone / video screen covers data structures and algorithms (more on these later.) Generally speaking:
- You’ll be asked an open-ended question. Clarifying questions are a must. Google will purposely leave out critical information, so check all assumptions before you begin. Your goal is to define a problem statement and devise requirements.
- Explain it algorithmically. Walk through your thought process before you write a single line of code.
- Convert it to workable code in your strongest language. Google expects some mistakes / bugs on the first draft; you’ll optimize and test next. Just get it all out now (considering corner and edge cases) and prepare for testing.
- Optimize and test. Refine your code. Check for cleanliness, follow with test cases, and identify bugs.
On-site
Once you pass the technical screen, you’ll move on to the on-site which consists of 5 rounds: 1 coding, 2 systems design, and 2 leadership / behavioral. Your day will begin with a quick meeting with a recruiter who will give you an overview of the process and some background on your interviewers. The panel varies, but interviewees report meeting with both junior and senior engineers and as well as other managers. You’ll also have a lunch break midday where you’ll be able to ask questions and speak informally with a peer or interviewer.
Coding
Google’s focus is on conceptual understanding rather than memorization, but you’ll still need to be really strong in at least 1 language - preferably C++, Java, Python, Go, or C. You’ll be whiteboarding or typing code into a Google doc so practice coding without syntactic support or autocomplete beforehand.
You may get conceptual questions as well, so make sure you’re comfortable with APIs, OOP, testing best-practices and thinking through edge cases!
System Design
While Google’s coding questions skew basic for EMs, you’re expected to bring it to the system design rounds. This makes sense - as a manager, you’ll lead the way for your engineers, which means combining theory, experience, and judgement to frame hard problems in ways that makes them workable.
Google specifically recommends “knowing how the internet actually works” - a surprising blind spot for many of us. We’ll cover specific systems design questions and offer some prep material in the next section.
Leadership / Behavioral
Okay, you’ve got a brilliant technical mind. But can you lead? That’s what Google’s getting at with its Leadership rounds. You’ll be asked about your past - your experience managing people and projects - and you’ll be assessed on your ability to support and grow a group. Here are a few key traits Google looks for:
- Leadership by influence
- The ability to maintain balance when facing team challenges
- The ability to quickly and accurately assess situations
- Individual and team development and retention
- Competence in the face of ambiguity and complexity
… As well as always delivering results, of course! More on these and specific behavioral questions next.
Sample Interview Questions
You’ll get a mix of technical and leadership / behavioral questions, broken up as follows:
Technical Questions
Algorithms and Coding
In addition to strong general coding skills, you should have a good understanding of basic algorithms as well as more advanced algos that you’ll likely run into while working on Google problems. Don’t stop at surface level understanding - review algorithm complexity and think through ways you’d improve / change them as needed. Specifically, we recommend studying:
- Sorting (including tradeoffs and efficiency in terms of time and space)
- Divide-and-conquer
- Dynamic programming / memoization
- Greediness
- Recursion (including using recursion as a tool to find better solutions as part of your process)
- Any algorithms linked to specific data structures (a big area to study for on its own)
- Big-O notation
- Data Structures
Spend a lot of time on data structures, as Google looks for a wide knowledge base. Study as many different data structures as you can including which algorithms go best with each and why. For Google problems, the most common are:
- Arrays
- Linked lists
- Stacks and queues
- Hash-sets, hash-maps, and hash-tables
- Dictionaries
- Trees / binary trees
- Heaps
… and graphs. Graphs are important enough to warrant their own section.
Graphs
Identifying when a problem can be analyzed using graph algorithms is especially useful at Google (a pioneer in search). Know the three basic ways to represent a graph in memory (objects and pointers, matrix, and adjacency-list) and be prepared to discuss the tradeoffs of each. Study basic graph traversal algorithms and BFS / DFS. Of course, be able to apply these in the real world - consider computational complexity, which is appropriate when, and how to implement them in code.
Math
Don’t forget to review basic combinatorics and probability theory - Google interviewers like Discrete Math 101 questions. If you’re practicing your coding skills, you should run into plenty of these problems, but make sure you have some basic conceptual knowledge of counting and probability as well as practical application.
System Design
As we mentioned before, Google’s coding questions might seem easy if you’ve got deep experience. Don’t expect the same during the system design rounds. Google is notorious for its high standards on system design questions, so spend a lot of time here. Topics to review include:
- SQL vs. NoSQL databases
- Load Balancing
- Principles of distributed systems
- Object-oriented design
If you tend to get nervous or stuck, focus first on defining the problem. Consider scope, scale, edge cases, and system maintenance. Then sketch out a high-level design in which you’ll work through coding frameworks, database options, capacity, etc. Finally, work on connecting these pieces. Taking this approach will save you from getting overwhelmed and diving too deep too soon. It also allows your interviewer to observe your structured thought process, and offers plenty of opportunity to ask questions.
For a full review of system design principles and example interviews, check out this complete System Design Interview Course.
Behavioral Questions
Time to switch gears and prep for behavioral rounds. Expect a mix of questions about your work history, your philosophical approach to project management, and hypotheticals meant to tease out your ability to lead. Check out our complete Engineering Management Interview Course for a full breakdown of the behavioral and people management questions you'll see in the Google EM interviews.
Leadership: The Fun Stuff Prepare to talk about your wins: how you resolved complex situations, overcame challenges, and delivered creative solutions under constraints. We recommend building a story bank from which you can pull anecdotes in the STAR format.
You will also be asked hypothetical questions meant to gauge your approach to team-building. Spend some time thinking about how you’d build and retain diverse teams, help individuals grow in their career, and fill skills gaps through the lens of “Googleyness” (covered below) to ensure that your approach meshes with Google’s unique culture.
Leadership: The Hard Stuff Of course, management isn’t all inspiration and celebration. Google’s famously non-hierarchical environment fosters great innovations, but it has its challenges as well. You’ll run into personality conflicts, ambiguity, and the stressful times. You’ll fail occasionally. This is the nature of work - but a top-notch EM is comfortable navigating complexity and ambiguity. He or she can (and likely has) resolved conflicts, smoothed clashing personalities, and learned from mistakes.
Think about times when things got tough, but you were able to wrangle a positive outcome. Times when you were able to balance process versus execution in the midst of a mess. And don’t be afraid to talk about failures, if asked. If you’ve learned from mistakes and misfortune, you’ll be showing the panel that you can handle hard times as well as the good.
Fit a.k.a. “Googleyness” Google’s looking for people who fit with its culture and will thrive in its unique environment. There are many definitions floating around, but specifically in the case of EMs, Google looks for:
- Comfort with ambiguity
- Bias to action
- Collaborative nature
If you’re curious, a team-player, and you want to succeed, you should do fine.
Tips and Strategies
-
Drill systems design: We’ve said it before, but it bears repeating: Google expects exceptional systems design performance because systems design questions mirror real working conditions at Google. Make sure to fill in any technical blindspots and do lots of mock interviews.
-
Get a referral, if you can: It's always worth securing a referral, if you can, but besides the obvious benefits, referrals can significantly speed up the interview process which can drag on at Google.
-
Practice coding outside of an IDE: Preferably on a whiteboard or within a google doc, and don’t skip the last step - always test when you’re finished.
-
Recommended resources: Google has provided some reading material to help you prepare. Check out The Google story, Life @ Google, Google Developers, Open Source Projects, and Github: Google Style Guide to learn more about Google, as well as The Google File System, Bigtable, MapReduce, Google Spanner, Google Chubby, and Google’s Publication Database for a more in-depth look at Google technology.
and finally... Practice, practice, practice. There's nothing better than actual interview practice. Exponent's daily peer mocks are perfect for this.