Assessment tips
- Confirm the current Google pattern from the drive mail before practising old papers
- Finish one problem or section fully before starting the next
- Revise the fundamentals listed in the round table on this page
Google Interview Experience 2026
Overview
How Google’s SWE interviews actually run, synthesized from recent candidate reports and Google’s public hiring guidance. We reorganized rounds, added prep notes, and flagged team/level variance - treat this as a prep map, not a script.
Reported total compensation for an India-based L3 new-grad hire varies widely by source - commonly cited in the ₹35-50 LPA range (base ₹18-25L plus RSUs and bonus), though some reports run notably higher with strong negotiation or competing offers. Treat any figure as a reported range, not a guarantee.
Round-wise process
| Stage | Duration | What it tests |
|---|---|---|
| Recruiter screen | 20-30 min | Background, logistics, timeline |
| Online Assessment (new grad/L3) | ~90 min | ~2 coding problems |
| Phone screen | 45-60 min | 1 coding problem, shared Google Doc |
| Onsite - Coding (2-3 rounds) | 45-60 min each | DSA, often non-standard phrasing |
| Onsite - System design (L5+) | 45-60 min | Distributed systems fundamentals |
| Onsite - Googleyness/Leadership | 45-60 min | Ambiguity, learning agility, influence without authority |
| Hiring Committee | 1-2 weeks | Independent packet review |
Real interview experiences
Experience 1: SWE, new grad L3 (2025)
Profile: B.Tech CSE, competitive programming background, one internship, off-campus application
Online Assessment
- Longest palindromic substring (DP approach), and a range-sum query problem solved with a segment tree.
- Both needed an optimal solution - a working-but-slow answer wasn’t enough to advance.
Phone screen
- Implement a rate limiter, discussing fixed window vs sliding window vs token bucket before writing any code.
- Done entirely in a shared Google Doc - no autocomplete, no compiler, no way to test-run the code.
Onsite - coding
- Median of two sorted arrays, expected the O(log(min(m,n))) binary-search approach, not just the merge-and-find brute force.
- A second round asked for a URL-shortener-style hashing scheme mid-problem, testing whether the candidate would ask about scale unprompted.
Onsite - Googleyness
- “Tell me about a time you had to work through ambiguity with little direction.”
- “Describe a time you influenced a decision without having authority over the people involved.”
- Interviewer stayed largely silent between questions, following a fixed guide rather than a free-flowing conversation.
Hiring Committee
- All interviewer write-ups compiled into one packet; committee (outside the hiring team) reviewed it about a week after the onsite.
Result: Selected
Takeaways
- What decided it: Narrating trade-offs before typing, plus treating Googleyness (ambiguity / influence without authority) as a scored round
- Common fail: Silent coding in the shared Google Doc, or a generic “why Google” that never names a team or problem
- How to practise: Solve medium DSA in a plain-text editor with no run button; rehearse two Googleyness stories with a concrete “what I did next”
Experience 2: SWE, new grad L3 (2024-2025)
Profile: B.Tech IT, strong personal projects, campus placement drive
What differed
- The online assessment leaned on graphs instead of DP: a BFS-based shortest-path variant with an added constraint that wasn’t in any textbook version.
- One onsite round shifted from coding into a lighter system-design discussion (distributed logging), even though the candidate was L3, not L5 - team-dependent variation in action.
- The Googleyness interviewer asked a direct follow-up on a “disagreement with a teammate” story: “What would you have done if they hadn’t agreed with you?”
Mistakes that hurt other candidates in the same cycle
- Writing code silently instead of narrating reasoning - interviewers can’t score an approach they can’t hear
- Treating “why Google” as a chance to praise Search or Gmail instead of naming a specific team or problem
- Giving up on a hard problem instead of stating a partial, correct approach with its complexity
Result: Selected
Takeaways
- What decided it: Talking through graph/BFS trade-offs and answering the Googleyness disagreement follow-up without freezing
- Common fail: Giving up on a hard problem instead of stating a partial correct approach with complexity
- How to practise: Time-box “narrate then code” drills; prepare a disagreement story with a forced “what if they still disagreed” follow-up
Experience 3: New grad SWE, India (2024-2025 staggered loop)
Profile: B.Tech; off-campus/new-grad track; multiple onsite slots spread across months
What differed
- Six interview touchpoints reported (not a single onsite week): tree problems with parent-pointer follow-ups, multi-source BFS, heap-heavy scheduling, and one round that went deep on tries under repeated query follow-ups.
- One Googleyness session felt “quiz-like” with a silent interviewer; another was described as light-hearted on the same trip - panel variance is real.
- Hiring decision staggered for the 2025 batch: strong aggregate feedback but weeks of waiting while headcount landed.
Result: Pending / delayed decision in source report (treat as a reminder to confirm timeline with recruiter)
Takeaways
- What decided it: Consistency across a staggered multi-month loop mattered more than one standout Googleyness session
- Common fail: Assuming a strong behavioural round can rescue a weak coding write-up before Hiring Committee
- How to practise: Keep a weekly DSA cadence through team matching; confirm timeline with the recruiter instead of reading silence as rejection
Experience 4: L3 SWE, India (2024 reject after team matching)
Profile: ~1 YOE; competitive programming background; LinkedIn outreach
Screening and onsite
- Phone screen: group-anagram-style string problem with easy follow-ups in ~30 minutes.
- Onsite spread across late nights (US/Canada/Mountain View interviewers): detailed line-by-line probing while coding, topological sort + priority-queue scheduling follow-up, thread-safety extension on a design question.
- Googleyness round finished quickly with standard conflict and ownership prompts.
Outcome: Rejected after process; feedback cited need for stronger DSA consistency - illustrates that one borderline round can fail HC or team match even with contest credentials.
Takeaways
- What decided it: Contest credentials were not enough once DSA consistency and Doc-format communication looked borderline
- Common fail: Optimizing for speed on LeetCode while under-practising line-by-line explanation and follow-up upgrades
- How to practise: Re-solve known problems aloud in a Doc; add one forced optimization or thread-safety follow-up each session
Team matching and timeline (India)
Public write-ups (Medium, InterviewExperiences.in) describe 5-8 months from first recruiter contact to offer for L3 Bengaluru roles, with team matching as a common bottleneck after onsite success. Prepare for manager calls that revisit system design choices on past work, not only “why Google.” If a team-fit call is cancelled, follow up with your recruiter - it sometimes precedes a rejection rather than a reschedule.
Questions that come up often
Coding / technical
- Longest palindromic substring - dynamic programming
- Median of two sorted arrays - binary search, O(log(min(m,n)))
- Implement a rate limiter - fixed window / sliding window / token bucket
- Range-sum query data structure - segment tree
- Graph shortest-path variants - BFS with added constraints
- Frog jump / DP state - reported in 2026 candidate lists
- Serialize and deserialize binary tree - recurring in India onsite reports
- LRU cache with expiration - design + follow-up extension (L4 accounts)
System design (L5+)
- Design a URL shortener
- Design a distributed cache
- Design a distributed logging/metrics pipeline
Googleyness / Leadership
- Tell me about a time you had to work through ambiguity with little direction
- Describe a time you influenced a decision without formal authority
- Tell me about a time you disagreed with a teammate’s approach
- Tell me about a time you learned a new technology or domain quickly
Practical tips for Google
- Practice in a plain-text editor with no autocomplete or run button - the format itself is part of what’s being tested.
- Narrate trade-offs out loud (hash map vs sort, BFS vs Dijkstra) before and while you code.
- Treat the Googleyness round as a scored interview, not a friendly chat - prepare real stories, not generic values statements.
- If a problem is genuinely hard, state a partial, correct approach with its complexity rather than going silent.
- Remember your interviewers don’t make the final call - staying consistent across every round matters more than one standout answer.
HR interview
After the technical rounds, Google’s Googleyness/Leadership round doubles as its behavioural evaluation, feeding directly into the Hiring Committee packet. Prepare those answers on the dedicated page rather than cramming them into this hub.
Sample answers for high-frequency questions
Use these as frames, not scripts - interviewers probe follow-ups.
Q. How do you merge overlapping intervals?
A. Sort the intervals by start time, then sweep left to right keeping one active interval. For each next interval, if its start is less than or equal to the end of the active interval, they overlap, so extend the active interval’s end to the maximum of the two ends; otherwise push the active interval to the result and make the current one active. Sorting dominates the cost, so the algorithm is O(n log n) time and O(n) space for the output. The classic follow-up is inserting a single interval into an already-sorted list, which drops to O(n) because no sort is needed.
Q. How do you find the longest substring without repeating characters?
A. Use a sliding window with two pointers and a hash map from character to its last seen index. Expand the right pointer one character at a time; when you hit a character already inside the window, jump the left pointer to one past that character’s last index so the window is valid again, then update the best length. Each character is visited at most twice, giving O(n) time, and space is O(k) where k is the size of the character set. The key detail interviewers probe is that you must move the left pointer forward only, never backward, or the window can become invalid.
Q. How does topological sort work, and how do you detect a cycle in a directed graph?
A. Kahn’s algorithm computes the in-degree of every node, pushes all zero in-degree nodes into a queue, and repeatedly pops a node, appends it to the ordering, and decrements the in-degree of each neighbour, enqueueing any that reach zero. It runs in O(V + E) time and O(V) space. If the final ordering contains fewer than V nodes, the remaining nodes are stuck in a cycle, so the graph is not a DAG and no topological order exists. The DFS variant instead colours nodes white, grey, and black, and reports a cycle the moment a DFS edge points at a grey node still on the recursion stack.
Q. Explain dynamic programming using the coin change problem.
A. Dynamic programming solves a problem by combining answers to overlapping subproblems and storing each answer once. For coin change with target amount A and coin denominations, define dp of i as the fewest coins that make amount i, with dp of 0 equal to 0 and every other entry starting at infinity. For each amount i, try every coin c with value at most i and set dp of i to the minimum of itself and dp of i minus c plus one. That is O(A times number of coins) time and O(A) space, and dp of A being still infinity at the end means the amount is unreachable.
Q. How do you find the median of two sorted arrays in logarithmic time?
A. Binary search on the partition point of the smaller array rather than on values. Pick a cut in array A, derive the matching cut in array B so the left halves together hold exactly half the total elements, then check the boundary condition that the largest element left of the cut in A is not greater than the smallest element right of the cut in B, and symmetrically for B. If the condition fails, move the binary search in A left or right accordingly. When it holds, the median is the maximum of the two left boundary values for odd total length, or the average of that maximum and the minimum of the two right boundary values for even length. This gives O(log(min(m, n))) time and O(1) space.
Tips from successful candidates
Interview tips
- Narrate trade-offs; expect “why” after every answer
- Only list projects you can defend under follow-ups
- Prepare 3-4 STAR stories for behavioural prompts
HR tips
- Know why Google, not just why the industry
- Be clear on location / notice period / higher studies
- Practise answers on the dedicated HR page
Sources
These links are research inputs we used to map round structure and recurring questions - not copied page mirrors. We reorganized reports into process tables, outcome notes, and prep takeaways for Google.
Outbound candidate write-ups and references:
For the company overview and FAQs, see the Google hub. For behavioural STAR prompts, use the Google HR page. For OA drills, use Google on placementpapers.app.