Google L4 Software Engineer Interview: Eight Rounds, No Offer

How the process went

1. Application

   Applied directly through Google's career portal; a recruiter reached out afterward, and the candidate had about a month to prepare before the first screen.

2. Screening rounds

   Two screening calls, each built around a single coding question, before the process moved to onsite.

3. Onsite rounds

   Onsite interviews were scheduled about two weeks after the screens and consisted of three coding rounds plus a short Googlyness (culture) conversation.

4. Team matching

   About a week after the onsite rounds, the recruiter said feedback had come in positively and arranged a team-matching call with a hiring manager, covering a high-level design question and a briefing on the team's work.

5. Eligibility hold

   After team matching, the recruiter said the role's years-of-experience requirement had been raised to three years, above the candidate's two years and ten months. The recruiter framed the pause as potentially lasting up to about two months; in practice the process resumed after roughly a month and a half, with one more round added.

6. Extended round

   The process resumed with one additional round focused on approach rather than implementation, after which the candidate waited about a month for a decision.

7. Outcome

   The recruiter reported the extended round's feedback was negative and closed the application without an offer, roughly six months after the process began.

Screening Round 1

Initial recruiter-scheduled coding phone screen

• A single coding question (the specific problem was written up separately by the candidate elsewhere and isn't detailed in this account); the interviewer expected the solution to be optimized further than the candidate initially took it.

Feedback came back as neither positive nor negative, tied to a mismatch in expectations about optimizing the solution further.

Screening Round 2

Open-ended geometry/optimization problem requiring clarifying questions before an approach

• Given a set of points in an X-Y plane representing possibly-overlapping rectangles, find a vertical line (which may pass through the rectangles) that splits the total area into two equal halves.

Solved with a binary-search approach after clarifying the constraints; feedback was positive and the candidate was told the screening stage had been cleared.

Onsite Round 1

Subarray problem with a complexity follow-up and a testing exercise

• Given an array of numbers, find all subarrays that form a "good arithmetic sequence" — one with a common difference of +1 or -1 (for example, {1,2,3} or {3,2,1}).
• Write unit test cases for the resulting solution.

Started with a brute-force approach, then optimized to O(n) after a follow-up request; feedback was positive.

Onsite Round 2

Scheduling design built on a small set of given blocking APIs

• Given a class with a blocking countWords() API and an isTaskCompleted() API, and N machines that can each process one job at a time, design a way to schedule word-count jobs across the machines while minimizing calls to the blocking API and keeping total completion time low.

Proposed a round-robin scheduler backed by a queue of free machines and a completion check to recycle them; the interviewer pushed with several follow-ups. Feedback was positive.

Onsite Round 3

Data structure design for randomized selection under a no-repeat constraint

• Design a music playlist shuffler that always returns a random track, where a track that just played cannot be returned again for the next K plays.
• Write unit test cases for the resulting solution.

Started with a queue-based approach at O(n) time and space, then optimized to O(1) time with O(K) space. Feedback was positive.

Googlyness

Short behavioral conversation about the candidate's current role and team-leadership scenarios · Short round

• How would you build a team from scratch?
• If you were appointed manager of an underperforming team, how would you approach improving its efficiency?
• How would you resolve a conflict within a team?

Team Matching

Conversation with a hiring manager covering background, a high-level design problem, and team fit

• One high-level design problem, where only the overall approach (not implementation detail) was expected.

The manager also described the team's current work and role responsibilities, and indicated they were comfortable moving forward.

Extended Round

Approach-only design question, added after the eligibility hold

• Design a library that determines whether a given boolean expression (for example, (a || b) && c) can ever evaluate to TRUE.
• How would someone without coding knowledge, but comfortable with the underlying math, use the library?
• What should the input format be, and how should the library be invoked?
• Which data structures should back the implementation, and why, given the space and time constraints?
• Write the associated class and API declarations (signatures only).
• Implement the core logic that evaluates whether the expression can be TRUE.
• What is the expected time and space complexity of that evaluation logic?

Proposed enumerating all 2^n truth assignments across the expression's variables; the interviewer said they wanted approach and reasoning rather than a full implementation. The discussion went well in the room, but the recorded feedback was ultimately negative.

Source

The questions and process facts come from the candidate's public write-up, linked below. The retelling above is our own summary.