The hiring process
| Round | Format | What's tested |
|---|---|---|
| Recruiter Screen | ~20-30 min | Fit, timeline and logistics |
| Technical Phone Screen | ~45 min | DSA coding in a shared doc |
| Onsite Coding (2-3 rounds) | ~45 min each | Deeper DSA under interviewer probing |
| AI Code Comprehension (2026, some loops) | ~45 min | Reading, debugging and optimizing code with AI assistance |
| System Design (L4+, deeper at L5+) | ~45 min | Designing a scalable system |
| Googleyness & Leadership (Behavioral) | ~45 min | Collaboration, ambiguity and growth |
Process and cutoffs vary by drive/team and change over time — confirm on the official careers page.
Round-by-round: exactly what's asked & how to prepare
Recruiter Screen
~20-30 minA recruiter confirms your background, target level, timeline and location, and outlines the loop. Sometimes a soft team match is discussed. Low-stakes but sets expectations and level.
- Your background and target level
- Preferred locations and timeline
- What the loop will contain
- Compensation basics and process
- Clarify your target level and be able to justify it
- Know your resume cold
- Prepare a crisp two-minute background pitch
- Ask about loop format and any in-person rounds
- Being vague about level or timeline
- Not knowing your own resume
- No questions for the recruiter
- Clear communication and realistic level expectation
- Genuine interest
- Logistical readiness
Technical Phone Screen
~45 minOne (sometimes two) coding interviews with an engineer in a shared document, no autocomplete or execution. You solve one or two DSA problems, discussing approach, complexity and edge cases out loud. This gates the onsite.
- Array/string manipulation with an efficiency twist
- Hashmap or two-pointer optimization
- Tree or graph traversal
- Complexity trade-off between approaches
- Edge-case and testing discussion
- Solve ~150 curated LeetCode problems across patterns (NeetCode 150 free)
- Practice coding in a plain doc while narrating
- Master time/space complexity analysis
- Drill dry-running code by hand
- Jumping to code before clarifying the problem
- Silent solving with no communication
- Ignoring edge cases and complexity
- Clarifying questions before coding
- Optimal approach with clear complexity
- Clean, correct, tested code
Onsite Coding (2-3 rounds)
~45 min eachTwo to three coding rounds on a whiteboard or shared doc covering strings, graphs, dynamic programming, sorting and shortest-path style problems. Interviewers push on optimization, complexity and correctness, and reward how you reason under hints, not just the final answer.
- Graph traversal or shortest-path variant
- Dynamic programming on strings or grids
- Interval or heap-based scheduling
- Backtracking with pruning
- Optimizing a brute force to an efficient solution
- Drill graphs, DP, heaps and backtracking patterns on NeetCode/LeetCode
- Practice narrating trade-offs and taking hints gracefully
- Time yourself at 30-35 minutes per problem
- Do mock interviews (Pramp, interviewing.io free tiers)
- Freezing instead of talking through a partial idea
- Ignoring hints from the interviewer
- Not verifying with test cases
- Structured problem decomposition
- Graceful use of hints
- Optimal, tested solution with complexity stated
AI Code Comprehension (2026, some loops)
~45 minA newer round where you use an AI assistant (e.g. Gemini) to read, debug and optimize an existing codebase. Interviewers evaluate AI fluency: precise prompting, validating and correcting AI output, and your own debugging judgment. Availability varies by team and level (flag as evolving).
- Understanding an unfamiliar codebase quickly
- Prompting the AI to locate and explain a bug
- Validating and correcting AI-suggested fixes
- Optimizing a function with human judgment over AI output
- Explaining trade-offs the AI missed
- Practice reading unfamiliar code and forming a mental model fast
- Practice prompting an AI to explain/debug code, then verifying it
- Build the habit of validating AI output rather than trusting it
- Review debugging techniques and reading stack traces
- Blindly accepting AI output without validating
- Vague prompts that waste time
- Losing your own reasoning by over-relying on the tool
- Effective, precise prompting
- Critical validation of AI suggestions
- Strong independent debugging judgment
System Design (L4+, deeper at L5+)
~45 minFor L4 you may get a lighter design discussion or one embedded round; a dedicated system-design round is standard from L5 up. You scope requirements, sketch components, discuss data models, APIs, scaling, and trade-offs, driving the conversation yourself. (Weight scales with level.)
- Design a URL shortener or rate limiter
- Design a news feed or notification system
- Data model and API for a scalable service
- Caching, sharding and consistency trade-offs
- Handling scale, failures and bottlenecks
- Study the free System Design Primer on GitHub
- Learn core building blocks: load balancers, caches, queues, sharding
- Practice a repeatable framework: requirements, high-level, deep-dive, trade-offs
- Do mock design sessions and time-box them
- Diving into details before clarifying requirements
- No discussion of trade-offs or failure modes
- Letting the interviewer drive the whole session
- Clear requirement scoping
- Sound component and data-model choices
- Explicit trade-off reasoning at scale
Googleyness & Leadership (Behavioral)
~45 minA behavioral round assessing comfort with ambiguity, collaboration, bias to action, ownership, learning from failure and intellectual curiosity. Expect structured stories from your experience; for new-grad it emphasizes potential and teamwork over demonstrated leadership.
- Navigating an ambiguous or changing problem
- A conflict or disagreement you resolved
- Learning from a failure or mistake
- Taking ownership beyond your assigned task
- A time you showed curiosity or self-driven learning
- Prepare 6-8 STAR stories mapped to ambiguity, conflict, failure and ownership
- Practice concise, specific, reflective delivery
- Read Google's re:Work resources on collaboration
- Rehearse learning-from-failure stories with real self-insight
- Vague stories with no measurable outcome or reflection
- Blaming others in conflict/failure stories
- Only 'I' with no collaboration
- Comfort with ambiguity and bias to action
- Genuine reflection and growth
- Collaborative, ownership-driven mindset
What to master
- Arrays, strings, hashmaps and two pointers
- Trees, graphs and traversal
- Dynamic programming
- Heaps, intervals and backtracking
- Time and space complexity analysis
- System design fundamentals (L4+)
- AI-assisted code comprehension and debugging
- STAR behavioral storytelling (Googleyness)
Eligibility
L3 is the new-grad/entry SWE level; L4 is mid-level with a few years of experience. System design weight increases with level (light or embedded at L4, dedicated at L5+). As of 2026 at least one in-person round is often required; loop specifics vary by team and level (flag as evolving).
Google SWE salary & compensation (2026)
Top-of-market comp; heavy RSU weighting that grows sharply with level.
| Role / Level | Experience | India — total CTC | US — total comp | What to know |
|---|---|---|---|---|
| L3 (SWE II / new grad) | 0–2 yrs | ₹35–55 LPA | $180K–235K | base + RSUs (4-yr vest) + ~15% target bonus |
| L4 (SWE III) | 2–5 yrs | ₹55–90 LPA | $260K–350K | stock share rises materially |
| L5 (Senior SWE) | 5–9 yrs | ₹90–160 LPA | $380K–520K | RSUs often exceed base |
| L6 (Staff SWE) | 9–13 yrs | ₹150–260 LPA | $550K–750K | equity-dominant total comp |
| L7 (Senior Staff) | 13+ yrs | ₹250–400 LPA | $750K–1.1M | large refreshers + performance multipliers |
How the package is structured
- US split ~ base 40–50%, RSUs 40–55%, bonus 10–15% at senior levels
- Annual RSU refreshers stack on the initial 4-year grant
- India comp is roughly 45–55% of US at same level; L5+ jumps are steep
- Bonus target ~15% base, scaled by GRAD/impact rating
Indicative 2026 market ranges aggregated from public sources (levels.fyi, Glassdoor, AmbitionBox, candidate reports). Compensation varies widely by location, team, level calibration, and negotiation — use these as directional benchmarks, not guarantees.
Your prep plan
- Days 1-4: NeetCode 150 core patterns (arrays, strings, hashmaps, two pointers)
- Days 5-7: trees, graphs and dynamic programming with timed practice
- Days 8-9: heaps, intervals, backtracking and mock coding interviews
- Days 10-11: system design fundamentals (L4+) with one mock
- Days 12-13: 6-8 STAR Googleyness stories, rehearsed aloud
- Day 14: full mock loop (coding plus behavioral, plus design if L4+)
Want this plan dated to your interview?
Upload your resume and tell Whis your interview date — get a personalized, day-by-day plan built around your gaps, then run Whis live in the interview.
Get my personalized planFrequently asked questions
Is system design tested for new grads (L3)?
Usually not as a dedicated round. System design is standard from L5 up; L4 may see a lighter or embedded design discussion. New-grad L3 loops focus on coding plus Googleyness.
What is the AI code-comprehension round?
A 2026 round where you use an AI assistant like Gemini to read, debug and optimize code, evaluated on prompting, output validation and your own debugging judgment. Availability varies by team and level.
How many coding rounds are there?
Typically a phone screen plus two to three onsite coding rounds, all DSA-heavy.
Can I fail on the behavioral round alone?
Googleyness is a real signal the hiring committee weighs; strong coding with a weak behavioral read can hurt or sink a packet.
Are interviews in India in-person now?
As of 2026 Google often requires at least one in-person round, sometimes a split of virtual coding plus an in-person onsite. Confirm with your recruiter.
What free resources should I use?
NeetCode 150 and LeetCode for coding, the System Design Primer on GitHub for design, and Pramp or interviewing.io free tiers for mocks.