Interview Experience - Google | Senior Software Engineer | L5
Summary
Job Role: Software Engineer (Senior Position)
Number of Rounds: 5
Offer Status: Pending
Location: Not location specific
Candidate Name: Not disclosing due to signed NDA
Interview Process
The interview process at Google consisted of the following rounds:
Phone Screen – A technical screening focused on coding.
Onsite Interviews (5 rounds)
Googleyness and Leadership
Coding (2 rounds)
System Design
Coding
Feedback collection and final decision
Preparation Guide
To prepare for this interview, I followed a structured approach:
Started with fundamentals: Linked List, Stack, Queue, Monotonic Stack, Array manipulation, prefix/suffix sum.
Deep focus on Binary Tree and Binary Search Tree (BT & BST).
Practiced BT and BST questions on TechieDelight and Medium.
Studied heap, priority queue, and TreeMap thoroughly.
Worked on advanced algorithms:
Backtracking
Grid traversing problems
Graph algorithms (DFS, BFS, MST, Dijkstra)
Attempted Dynamic Programming, though it remains a weak area.
Solved 150+ LeetCode problems, focusing on tricky ones such as sliding window, monotonic stack, and priority queue.
Total preparation time: 10 weeks (6-8 weeks might be sufficient for others).
Interview Rounds
Round 1: Phone Screen
Difficulty Level: Medium
Problem: Binary Tree traversal involving horizontal distance
Experience:
My prior practice on Binary Trees helped significantly.
Initially solved the problem using recursion (DFS), but it was suboptimal.
Optimized the solution by switching from TreeMap to HashMap and using min/max keys.
The interviewer appreciated my progression from a suboptimal to an optimal approach.
Key Learnings:
Collections.sort()in Java is stable.TreeMap operations have a log(N) complexity.
DFS can sometimes be a better choice than BFS in certain tree-based problems.
Round 2: Onsite - Googleyness
Difficulty Level: Medium
Problem: Behavioral round, no coding questions
Experience:
Discussed failures, values, work experiences, and the impact of others on my success.
Kept responses honest and genuine.
While I received positive feedback, the evaluation criteria remain unclear.
Key Learnings:
Be authentic and introspective.
Prepare to discuss failures and how you learned from them.
Cultural fit is an important aspect of Google's hiring process.
Round 3: Onsite - Coding Round 1
Difficulty Level: Easy
Problem: Array manipulation and game state evaluation
Experience:
The question was easier than expected but required careful traversal (row-wise, column-wise, diagonally).
Ensured all edge cases were handled.
Optimized the solution by reducing redundant traversals.
Key Learnings:
Even "easy" problems can be deceptive—stay cautious.
Focus on clean code and edge case handling.
Be ready to optimize your initial approach.
Round 4: Onsite - Coding Round 2
Difficulty Level: Hard
Problem: Indirect graph traversal
Experience:
Initially attempted BFS, but later realized DFS was a better choice.
Lost some time due to this mistake but adapted quickly.
Interviewer granted an extra 5 minutes to refine my solution.
Managed to implement a decent DFS structure, but ran out of time for thorough testing.
Key Learnings:
Choosing the right approach (DFS vs BFS) is crucial.
Time management plays a significant role.
If stuck, ask clarifying questions to avoid unnecessary detours.
Round 5: Onsite - System Design
Difficulty Level: Hard
Problem: Designing an existing distributed system
Experience:
Had to adapt my strategy in real-time based on interviewer feedback.
Asked clarifying questions before diving into the design.
Evaluated multiple approaches, discussing tradeoffs, bottlenecks, and scalability concerns.
Considered tier-1 services, API design choices (GET vs POST), and system reliability.
Key Learnings:
Be flexible and adapt to unexpected changes in the problem statement.
Clearly explain your thought process at every step.
Consider scalability and reliability factors in a distributed system.
Round 6: Onsite - Coding Round 3
Difficulty Level: Hard
Problem: File manipulation problem (later found on LeetCode Hard)
Experience:
Took time to understand the problem fully before coding.
Wrote the initial solution, then iterated with bug fixes and improvements.
Solution was mostly optimal, except for potential buffer reuse.
Identified a while(true) loop, which the interviewer accepted for the interview setting but noted could be improved in real-world scenarios.
Key Learnings:
Take your time to fully grasp the problem before jumping into coding.
It's okay to have less-than-perfect code if you can justify and explain improvements.
Maintain focus even in later rounds when fatigue sets in.
Final Thoughts
Preparation Strategy Matters: A structured approach focusing on foundational concepts and advanced problem-solving proved helpful.
Time Management is Key: Allocating sufficient time for testing and optimizations is crucial.
Approach Flexibility: Being adaptable and switching strategies mid-way (BFS vs DFS, API tradeoffs) was tested throughout the process.
Behavioral and System Design Rounds Are Crucial: Many candidates focus only on coding, but Googleyness and System Design rounds are equally important.
Stay Calm Under Pressure: Not all rounds will go perfectly, but maintaining a composed mindset significantly helps.
Overall, it was a challenging yet insightful experience. Awaiting final feedback from Google.