Google L4 | Bangalore | 2025
Summary
I interviewed for an L4 Software Engineer role at Google Bangalore in April 2025. After navigating through a phone screen, multiple DSA rounds, and a Googlyness assessment, which involved numerous reschedules, I unfortunately faced rejection, resulting in a 12-month cooldown period.
Full Experience
Hi Everyone,
I had my Google interview experience in April 2025. A recruiter approached me and scheduled an initial phone screen after I requested a week's preparation time. The phone screen involved a question that boiled down to using a Min Heap of size K to maintain the top K elements. I coded the solution and walked through it.
Ten days later, I received feedback: I solved the problem without hints but didn't walk through the code until asked. I was selected for onsite rounds and given 26 days to prepare.
All four onsite rounds (three DSA, one Googlyness) were scheduled for the same week.
📞 Round 1: This round had a straightforward Topological Sorting + BFS question. The interviewer, from an infra team, seemed disengaged, yawning and toggling her camera. She struggled to understand Kahn's algorithm, but was satisfied once I coded and explained it.
📞 Round 2: Rescheduled as the interviewer didn't join.
📞 Round 3: With a Principal Engineer who joined late. He started by asking if I was tense, which paradoxically made me tense. The question was a Medium-level Line Sweep Algorithm problem with intervals. I answered and coded, seeming to satisfy him. At the 37-minute mark, he asked about duplicates in interval ranges. I began explaining the necessary logic changes, but he told me to stop, saying we might run out of time. Lesson learnt: Always consider duplicates, even if not explicitly in sample input or initially mentioned.
📞 Round 3 (Rescheduled): Interviewer didn't join.
📞 Round 4 (Googlyness): Rescheduled as interviewer didn't join.
📞 Rescheduled Round 2: This interviewer was super interactive. The initial question involved log messages (string + timestamp) and printing only if a message hadn't appeared in the last 10 seconds. I used a simple map<string, int> and updated timestamps. I coded the approach, modifying the structure based on his expectations.
Follow-up 1: He asked about the bottleneck in real-time. I identified memory if all messages were unique. I proposed a cleanup using a queue and map, which he agreed with, and I coded it quickly.
Follow-up 2: A log message should be printed only if it hadn't occurred in the previous 10 seconds and wouldn't occur in the next 10 seconds. I couldn't figure it out in 5 minutes, even with a hint to use the previous cleanup function. I solved it just after the interview. Lesson learnt: Always focus on the interviewer's hints.
Rescheduled Googlyness 2: A Russian interviewer joined, thinking it was a DSA round, so it was cancelled and rescheduled.
Rescheduled Googlyness 3: Recruiter emailed that the interviewer had an emergency, so it was rescheduled again.
Rescheduled Googlyness 4: Finally, an L3 interviewer from Warsaw who was super cool. After four postponements, I had mastered all Googlyness questions and was ready with four STAR pattern stories. She was very impressed, and I felt confident about a strong hire here.
Final Verdict: ❌ Rejection. No feedback was provided. I'm now in a 12-month cooldown period, but the recruiter said she'd reach out again. I will definitely try again after the cooldown.
Interview Questions (6)
The question required me to use a Min Heap of size K to continuously maintain the top K elements from a stream of incoming data.
This was a straightforward problem that required applying Topological Sorting, specifically using a Breadth-First Search (BFS) based approach.
The problem involved applying the Line Sweep Algorithm to efficiently handle and process a given set of intervals.
I was given a stream of log messages, each consisting of a string message and a timestamp. The initial task was to print a message only if the same message had not occurred in the last 10 seconds relative to its current timestamp. My interpretation for printing was if the current_timestamp - last_seen_timestamp > 10. Example: If 'Leetcode' appears at timestamp 6, then again at 15. If 15-6=9, it implies it was seen within 10s, so it should not print again. The original prompt stated: 'Print only those messages if the same message is not present in last 10 seconds.'
This was a follow-up to the log message filtering question. The interviewer asked about the bottleneck of the previous approach in a real-time system, specifically regarding memory usage if all messages were unique.
This was a second follow-up question. The requirement was to print a log message only if it had not occurred in the previous 10 seconds and would not occur in the next 10 seconds relative to its timestamp. For example:Leetcode 6Leetcode 15Java 1Java 12Java 23
Output:Java 12 (as 'Java' is not present in the time window [2,22])Java 23 (same logic for 'Java 23')
Preparation Tips
My key takeaways and preparation insights include: always asking for a mock interview with the recruiter when onsite rounds are scheduled for Google, as the interview time is very tight (typically 2-3 minutes for intro, 37 minutes for the problem, and 5 minutes for candidate questions). For an L4 role, the grading criteria are extremely strict, expecting production-ready code with thorough handling of every corner case. I also learned to always walk through my code after writing it, even if the interviewer doesn't explicitly ask. For the Googlyness rounds, after multiple postponements, I had extensively practiced and mastered common behavioral questions, preparing four distinct stories using the STAR pattern, which significantly impressed the interviewer.