Google L4 Software Engineer Interview Guide: Phone Screen, Onsite Coding and Googleyness
Prepare for Google software engineer mid level interviews with reported assessment patterns, interview questions, and preparation advice.
On this page
Last reviewed November 10, 2026.
For SWE III / L4 candidates.
Built by the Codinzhub team from Google interview experiences that candidates shared, including the ones posted on Codinzhub. Each experience is one person's interview, and Google changes its process by year, level and team, so use this as a map, not a promise.
The 30-second version. A recruiter call, a phone screen or R1 (one coding round, sometimes with a behavioral round), then an onsite of two or three coding rounds plus Googleyness. System design is rare at L4. The problems are long, story-shaped and often ask you to design a small class. The hiring committee can down-level you to L3.
Round-by-round breakdown
Stage 1: Application, where candidates applied
How it works. Most L4 experiences do not say how the candidate applied. One L3 candidate was contacted by a recruiter and asked for months to prepare, and another applied with a referral.
Stage 2: Shortlisting, how candidates moved forward
How it works. A recruiter call, then for most candidates the work-style hiring assessment described in the main Google guide. You can ask the recruiter for preparation time: one L3 candidate took about three months before the phone screen.
Stage 3: Phone screen
At a glance
- Length: 45 minutes
- Questions per round: 1 problem, sometimes hard, plus follow-ups
- What was asked: lowest common ancestor, DP on strings, recursive file systems
- Most common: no single question repeats
How it works. One 45-minute coding round in a shared document. One candidate describes a single hard question solved two ways with a dry run. Passing it gets you to the onsite.
Questions candidates reported:
| Question (our summary) | Follow-up reported |
|---|---|
| Closest common manager of K employees in an org chart (lowest common ancestor) | Optimise for K and tree height; many queries |
| Count the ways to spell a word with periodic-table symbols | None |
| Total size of a file or directory by ID | Check the file system is valid |
| A range-tracking problem the candidate later matched to Range Module | Time management |
More questions: Browse Google questions.
Stage 4: The interview loop
How it works. The onsite has two or three 45-minute coding rounds and a Googleyness round, sometimes in person at Mountain View or Sunnyvale. One candidate found the onsite computer hard to use. One report had an object-oriented design round; one had an AI-assisted coding round.
Onsite coding rounds
At a glance
- Length: 45 minutes each, 2 or 3 rounds (some loops had 3 or 4 coding rounds in total)
- Questions per round: 1 main problem and a chain of follow-ups, often a class to design
- What was asked: class design, parsing, graphs, sliding windows and DP
- Most common: the piano hand span and course prerequisites
Questions candidates reported:
| Question (our summary) | What it tests |
|---|---|
| Temperature monitor: insert, moving average of the last N, max in O(1) | Deque design |
| Shortest grid route that makes every delivery and returns (under 10 points) | BFS + bitmask DP |
| Fewest hand lifts to play notes within a span | Sliding window |
| Replace variables in a string from a database, with nested names and cycles | DFS in a class |
| Fill a template from a key-value map with nested keys | Parsing, recursion |
| Merge two trees of named nodes: one tree's order, the other's values | Tree recursion |
| A range-update problem that needed a segment tree | Segment tree |
| Shortest Word Distance variant, then a class with helper methods | Arrays, class design |
| Bookshelf with a bookmark and CRUD operations | Object-oriented design |
| Longest continuous increasing subsequence and a second array problem | Arrays |
| Which players' ranks are fixed by match results | Graph reachability |
| Most active user in a message log; then O(1); then the top K | Hash map, heap |
| Course Schedule style prerequisite checks | Topological sort |
| HTTP router with path parameters | Trie |
| Logger rate limiter; Meeting Rooms II; Graph Valid Tree; friend recommendations | Mixed |
| Graph problems told as long stories, one with two parts | Graphs |
More questions: Browse Google questions.
Googleyness round
At a glance
- Length: 45 minutes
- Questions per round: 3 to 4 questions with deep follow-ups
- What was asked: workload, changing direction, conflict, motivation
- Most common: a disagreement with a colleague
How it works. 45 minutes. One interviewer kept pushing on every answer: what was the customer impact, and why did the problem happen at all?
Questions candidates reported: more tasks than expected; a time you had to change direction; disagreeing with a colleague; why you are leaving, why Google, and your expectations.
More questions: Browse Google questions.
System design (rare at L4)
At a glance
- Length: not stated
- Questions per round: 1 design
- What was asked: offline sync, post search
- Most common: none repeated
Two designs appear in the L4 data: offline sync and post search. Most L4 loops had none.
More questions: Browse Google questions.
Stage 5: Hiring committee, team match and offer
How it works. After positive feedback the packet goes to the hiring committee. In one report the committee approved L3 instead of L4 a week later, and team matching started. In one experience, the candidate had three team-match calls before an offer.
Topics to prioritise
Across these experiences, the most common topics are behavioral, trees, arrays, backtracking, DP, graphs, object-oriented design. Class-design problems with follow-ups are the most typical L4 format.
The Codinzhub Next-Round Playbook
What L4 candidates who moved on did. Put together by the Codinzhub team from the L4 experiences in this guide.
To get past the phone screen
- Ask for preparation time if you need it. Recruiters agreed to delays of weeks or months.
- Expect one problem that may be hard. Solve it two ways if you can and dry-run it.
To get past the onsite
- Clarify, agree on the approach, then code while explaining every step. Optimal code alone was not enough for one candidate.
- Set a time limit on edge-case discussion. One candidate was left with 12 minutes to code.
- Keep the better approach and ask for a hint on the hard part, instead of falling back to brute force.
- Practise class-design problems with follow-ups: a monitor, a router, a template engine.
To get past Googleyness
- Prepare stories that survive three "why" questions. One candidate with good coding was rejected after a relentless behavioral round.
To keep the level
- Strong follow-ups matter. One L4 loop was approved at L3 by the hiring committee.
FAQ
Do I need system design for L4?
Usually not. Only a few L4 loops included a design topic.
Can I be down-levelled?
Yes. One L4 loop was approved at L3 by the hiring committee.
About this guide
This guide is researched and written by the Codinzhub team. We read every Google interview experience we could find, kept only what candidates actually described, and rewrote it in our own words. Questions are our own short summaries; the practice links point to similar problems, not the exact interview questions. Found something out of date? Share your own experience on Codinzhub and we will update the guide.
Keep track of what you’ve learned.