Google L3 onsite interview: phone screen, four coding rounds, one behavioral round, no offer (Seattle, 2019)

GoogleL3 Software Engineer·Seattle, WA·Interviewed September 2019No offer

Updated July 17, 2026

This account is from a candidate's second attempt at interviewing with Google for an L3 role, after an earlier unsuccessful attempt. The phone screen, in September 2019, covered two problems back to back — a tree-splitting variant and a dynamic-programming problem on a grid — and ran close to the full 30-minute slot before the interviewer introduced the second question. Three days later, the candidate was invited onsite for four technical rounds plus one behavioral round.

The candidate came away from most rounds feeling solid, particularly the tree-traversal round with its max-depth follow-up and the grid BFS round with its parallelization follow-up. The exception was the first onsite round, a binary-search counting problem, where the candidate's solution did not hold up to O(log n) in the worst case; looking back, the candidate identified that round as the likely turning point. The loop ended without an offer.

How the process went

Phone screen
About 30 minutes, covering a tree-splitting variant and a grid dynamic-programming problem; the interviewer offered to swap out the second problem if time ran short.
Onsite scheduling
Three days after the phone screen, the candidate was invited onsite for four technical rounds and one behavioral round, held in a single day in Seattle.
Lunch
An informal lunch with a current employee covered general questions about the company; no technical content.
Decision
No offer. The candidate attributes the outcome primarily to the first onsite round.

Phone screen

Coding — tree restructuring and grid dynamic programming · ~30 min

A variation of splitting a binary tree into a forest after removing a given set of nodes.
A dynamic-programming problem on finding the largest square of 1s in a binary matrix (a maximal-square variant).

The interviewer offered to swap out the second problem if the candidate needed more time on it, with about 10 minutes left on the call.

Onsite round 1

Coding — binary search on a sorted array

Given a sorted array, count how many times a target value occurs, aiming for O(log n) time.

The candidate's approach recursively searched both halves once the target was located; in the worst case (an array filled entirely with the target) this did not achieve O(log n). Looking back, the candidate considers this round the likely deciding factor in the outcome.

Onsite round 2

Coding — binary tree traversal without extra space

Given a node in a binary tree (not the root), find its next right neighbor without using extra space.
Follow-up: each node also stores a max-depth value (the larger of its children's max depth, plus one); use that value to prune the search.

The candidate first suggested level-order traversal as a brute-force option, which the interviewer then ruled out; the solution instead walked upward from the query node using parent pointers and a depth counter.

Onsite round 3

Coding — trie-based word game

In a multiplayer word game (Ghost, played among N players), each move adds one character to a shared string; a character can only be added if the resulting string is a valid prefix of some dictionary word but not itself a complete word. Determine a legal next move.
Follow-up: choose a next character that guarantees a win under the same rules.

A trie built from a dictionary of valid words was used to check whether a candidate character kept the string as a non-terminal prefix. The candidate's proposed approach to the win-guarantee follow-up, counting terminal versus non-terminal paths, did not fully hold up, and that part of the round ended without a complete solution.

Onsite round 4

Coding — grid BFS for facility placement

A variation of 'Shortest Distance from All Buildings': given an office grid marking employee desks, walls, and empty spaces, find the empty space that minimizes total walking distance across all employees.
Follow-up: how would the BFS-based solution be parallelized across threads?

The solution ran a BFS from each employee, accumulating distances into a shared grid, then looked for the cell(s) with the lowest total distance.

Onsite round 5 — Behavioral

Behavioral

Describe a time you were unhappy with the direction a project was taking.
What is the most technically difficult thing you have worked on?
What are your career ambitions, and what is your plan for pursuing them?
Describe a time you had to disagree with your team.
Describe a time you went above and beyond to help your team.

Key takeaways

If you propose a brute-force option like level-order traversal and the interviewer rules it out, pivot quickly to a more constrained approach — here, parent-pointer traversal with a depth counter got the tree round back on track.
For array or search problems, stress-test an O(log n) claim against a worst-case input (like an array filled with one value) before presenting it as final — that gap in the first onsite round stood out to the candidate in hindsight.
When a follow-up shifts from construction into probability or open-ended guarantees, name that shift explicitly rather than forcing a counting-based shortcut that doesn't hold up.
Ask how much time is left before starting a second phone-screen problem, so pacing decisions are based on the actual clock rather than assumption.
A round that goes well procedurally is not a promise of the overall result — treat every round as equally consequential, since a single early round shaped this candidate's outcome.

Practice a Google interview

Rehearse out loud against the kinds of questions in this story — with an AI interviewer that asks follow-ups.

Practice this interview

Source

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

Candidate's public write-up on LeetCode Discuss