google logo
Google· SDE II

Google L4 | Bangalore | 2025

Result
Rejected
Location
Bangalore
Posted
1 Oct 2025
997 reads

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.

How it went

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.

Questions asked (6)

  1. 01

    Maintain Top K Elements in a Stream

    Data Structures & Algorithms

    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.

  2. 02

    Topological Sort + BFS Question

    Data Structures & Algorithms · Medium

    This was a straightforward problem that required applying Topological Sorting, specifically using a Breadth-First Search (BFS) based approach.

  3. 03

    Line Sweep Algorithm with Intervals

    Data Structures & Algorithms · Medium

    The problem involved applying the Line Sweep Algorithm to efficiently handle and process a given set of intervals.

  4. 04

    Log Message Filtering (Print if not seen in last 10s)

    Data Structures & Algorithms

    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.'

  5. 05

    Log Message Filtering - Memory Optimization (Cleanup)

    Data Structures & Algorithms

    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.

  6. 06

    Log Message Filtering (Not in previous 10s AND next 10s)

    Data Structures & Algorithms

    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 6
    Leetcode 15
    Java 1
    Java 12
    Java 23
    Output:
    Java 12 (as 'Java' is not present in the time window [2,22])
    Java 23 (same logic for 'Java 23')

How they prepared

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.

Know someone preparing? Send it to them:WhatsAppLinkedInX

Interviewed at Google recently?

Write up your rounds while you still remember the questions. It helps the next person more than you would think.

Share your experience
Discussion 0

Questions for the author, or how your own interview compared.

Join the discussion

Sign in with Google to comment or ask the author a question.

No comments yet

Be the first to share your thoughts and start the discussion!