Google Software Engineer Interview: Questions, Process & Prep
Google's SWE interview is a recruiter screen, one technical phone screen, then 4-5 virtual onsite rounds: 2-3 coding (DSA on Google Docs), system design (L4+), and a Googleyness/leadership round. Hiring committee and team match follow. Difficulty centers on LeetCode medium-hard graphs, trees, and DP.
The Full Google SWE Interview Loop
Google runs a structured, committee-driven loop that is intentionally team-agnostic until the end. You interview for a level, not a specific team; team matching happens after you pass. Below is the standard loop for an experienced or new-grad SWE candidate. Note Google rarely uses a separate timed online assessment (OA) for industry hires, but does run a coding sample / online assessment for some new-grad and intern pipelines.
| Stage | Format | What it tests |
|---|---|---|
| Recruiter screen | 30 min call | Background, target level (L3/L4/L5), timeline, role calibration |
| Online assessment (some new-grad/intern only) | Timed, 2 coding problems | Fundamental DSA, code correctness under time |
| Technical phone screen | 45 min, shared Google Doc | 1-2 coding problems, no IDE/autocomplete, live reasoning |
| Onsite: Coding x2-3 | 45 min each, virtual | DSA, edge cases, complexity analysis, clean code |
| Onsite: System design (L4+) | 45 min | Scalable distributed design, tradeoffs, estimation |
| Onsite: Googleyness & Leadership | 45 min behavioral | Collaboration, ambiguity, values, GCA (general cognitive ability) |
| Hiring committee (HC) | Async packet review | Holistic hire/no-hire from interviewer feedback + scores |
| Team match | Calls with hiring managers | Mutual fit; offer is finalized after a team commits |
Coding Rounds: Themes, Difficulty & Language Notes
Coding is the backbone of every loop, even for senior candidates. Problems skew toward LeetCode medium with one or two hard-leaning twists. Google interviewers care less about whether you memorized the optimal trick and more about structured problem decomposition, correct edge-case handling, and tight time/space complexity analysis. You typically write in a plain Google Doc with no syntax highlighting or execution, so clean, compilable-looking code matters.
Recurring DSA themes at Google: graphs (BFS/DFS, topological sort, union-find), trees and tries, dynamic programming, hash maps, two pointers / sliding window, heaps and intervals, and matrix traversal. Google has a long-documented fondness for graph and grid problems and for problems with a clean recursive structure that you then optimize.
- Difficulty: mostly LeetCode medium, expect 1-2 hard elements or a follow-up that raises the ceiling.
- Language: any mainstream language is fine — Python, Java, C++, Go are common. Pick the one you are fastest in.
- Always state brute force first, then optimize; verbalize complexity (Big-O) before the interviewer asks.
- Dry-run your code on an example and handle empty/null/overflow edge cases unprompted.
- Practice on the NeetCode 150 / Blind 75 corpus — Google questions cluster heavily in graphs, trees, and DP within those lists.
System Design Expectations by Level
System design is generally introduced at L4 and becomes heavily weighted at L5. For L3 (entry / new-grad) you are unlikely to get a full distributed-systems round, though you may face a lighter object-oriented or API design discussion. The bar rises sharply with level: L4 should drive a competent design with prompting; L5 is expected to own the problem, surface tradeoffs unprompted, and reason about failure modes and scale.
- Expect open prompts like 'design a URL shortener,' 'design a rate limiter,' or 'design a distributed cache.'
- Drive structure: requirements -> API -> data model -> high-level architecture -> bottlenecks -> tradeoffs.
- Do back-of-envelope capacity estimation (QPS, storage, bandwidth) out loud.
- Name concrete components and tradeoffs: SQL vs NoSQL, sharding strategy, consistency vs availability, queue vs sync.
| Level | Title | System design expectation |
|---|---|---|
| L3 | Entry / SWE II | Usually no full design round; light OOD/API design or data modeling may appear |
| L4 | SWE III | Design a scalable service end-to-end; partitioning, caching, load balancing with some guidance |
| L5 | Senior SWE | Lead ambiguous design; deep tradeoffs, consistency models, capacity estimation, failure handling, evolution over time |
Behavioral: Googleyness, Leadership & GCA
Google evaluates four attributes across the loop: coding/role-related knowledge (RRK), general cognitive ability (GCA), leadership, and 'Googleyness.' The dedicated behavioral round probes Googleyness and leadership through past-experience questions, while GCA shows up as how you reason through ambiguity in any round.
Googleyness covers comfort with ambiguity, bias to action, intellectual humility, collaboration, and putting the user first. Frame answers with the STAR method (Situation, Task, Action, Result) and lead with quantified outcomes. Expect questions on conflict, a project that failed, influencing without authority, and prioritizing under unclear requirements.
- Prepare 6-8 STAR stories spanning conflict, ambiguity, leadership, failure, and cross-team impact.
- GCA is assessed by how you decompose unfamiliar problems — narrate your reasoning, ask clarifying questions.
- Show intellectual humility: acknowledge tradeoffs and what you'd do differently.
- ResuMax's interview hub lets you rehearse system design with a Socratic coach and drill STAR behavioral answers, alongside a coding checklist over NeetCode 150 / Blind 75.
A Concrete 6-8 Week Prep Plan
This plan assumes 8-12 hours/week. Compress to 6 weeks by doubling weekly coding volume if you already have a strong DSA base.
| Week | Focus | Concrete goal |
|---|---|---|
| 1 | DSA refresh | Arrays, strings, hash maps, two pointers — 15-20 easy/medium problems |
| 2 | Trees & graphs | BFS/DFS, topological sort, union-find — 20 problems; this is high-yield for Google |
| 3 | DP & recursion | 1D/2D DP, memoization, backtracking — 15-20 problems |
| 4 | Heaps, intervals, tries | Mixed-medium set; start timing yourself to 30-35 min/problem |
| 5 | System design (L4+) | Study 6-8 canonical designs; do 3 timed mock designs out loud |
| 6 | Behavioral + GCA | Write and rehearse 6-8 STAR stories; 2 mock behavioral sessions |
| 7 | Full mock loops | 2-3 end-to-end mocks in a plain doc, no IDE; review feedback |
| 8 | Weak-spot drilling + rest | Re-do missed problems; light week before the loop, sleep well |
Honest, Google-Specific Tips
A few things are distinctly Google and worth optimizing for. The loop is calibrated by a hiring committee that never met you, so your interviewer's written notes are the product — make your reasoning legible and your code clean.
- You code in a Google Doc with no autocomplete or execution — practice writing syntactically correct code by hand.
- Communicate constantly: silent solving reads as a weak signal even if your answer is right.
- Always optimize after brute force and state complexity; interviewers explicitly grade this.
- Team match is separate from passing — you can pass HC and still wait for a team; keep the recruiter engaged.
- Down-leveling happens: if you target L5 but the signal reads L4, you may get an L4 offer rather than a reject.
- Don't skip behavioral prep — strong coders fail loops on weak Googleyness/leadership signals.
ResuMax tailors your resume to each role, scores it like a recruiter, and preps you for interviews.
Get started freeFrequently asked questions
How many interview rounds does Google have for software engineers?
Typically a recruiter screen, one 45-minute technical phone screen, then 4-5 virtual onsite rounds (2-3 coding, system design for L4+, and a Googleyness/leadership round), followed by hiring committee review and team match.
How hard are Google coding interviews?
Mostly LeetCode medium with one or two hard-leaning follow-ups. Themes recur in graphs, trees, dynamic programming, and hashing. Google weighs structured reasoning, edge cases, and stated Big-O complexity as much as the final answer.
Do I need system design for an entry-level (L3) Google role?
Usually not a full distributed-systems round at L3. You may get light object-oriented or API design. System design is introduced at L4 and weighted heavily at L5 for senior candidates.
What is 'Googleyness' in the interview?
It's Google's values-and-collaboration signal: comfort with ambiguity, bias to action, intellectual humility, user focus, and teamwork. It's assessed in the behavioral round, best answered with quantified STAR stories.
What language should I use in a Google coding interview?
Any mainstream language — Python, Java, C++, or Go are all common. Use the one you write fastest and most correctly, since you code in a plain Google Doc without autocomplete or execution.
How long should I prepare for a Google SWE interview?
Plan 6-8 weeks at 8-12 hours/week: DSA refresh, heavy graphs/trees/DP practice, system design for L4+, STAR behavioral stories, then full mock loops in a plain doc before the real loop.