Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA · AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
    int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
    }
    return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

How to Crack Google: The Software Engineer Interview, From Real Experiences

20 min read

Prepare for Google software engineer interviews with reported assessment patterns, interview questions, and preparation advice.

In this article
On this page

Last reviewed November 10, 2026.

For interns, new grads, L4 and L5+.

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. An online hiring assessment (a work-style questionnaire, and for many roles a 2-question coding test), then a first loop of one 45-minute coding round and one 45-minute Googleyness round, then an onsite of two or three 45-minute coding rounds (L5+ adds system design). Each round is usually one main problem and a chain of follow-ups, written in a Google Doc that you cannot run. After that, a hiring committee and team matching, which can take weeks. The one habit that matters most: agree on the problem and your approach out loud before you write a line, then keep talking while you code.

What this guide is, and what it is not

It is a map of the Google process as candidates describe it today, the question patterns that keep coming back, the follow-ups you should expect, and a six-week plan you can finish.

It is not a list of leaked questions, a promise about what you will be asked, or an offer rate. Most reports do not state an outcome, and people who write up interviews are not a random sample.

Round-by-round breakdown

The order below is what most candidates went through. Each stage starts with how it works, then lists the questions candidates reported. Not every candidate had every stage, and the order changes by level.

Stage 1: Application, where candidates applied

How it works. Candidates got in through four routes.

ChannelWhat candidates said
Campus hiringGoogle visited the college or ran a campus drive. Common for intern and new grad roles in India.
ReferralA Google employee referred them. Referrals moved some candidates to a recruiter call sooner, but one intern still waited about 40 days for the next step.
Careers siteApplied directly. Other accounts describe a rejection email first, then a recruiter getting in touch weeks later.
Recruiter reached outA recruiter got in touch first. Separately, one intern was invited after finishing in the top 1,500 of a Google coding contest.

What helped. A referral, a resume with real numbers you can defend, and active coding profiles. Recruiters asked about coding-practice, Codeforces and CodeChef in several reports.

Stage 2: Shortlisting, how candidates moved forward

How it works. After you apply, Google filters in two ways before any interview.

  1. Hiring assessment (most 2025-26 reports). An email arrives soon after you apply, often the next day, with a questionnaire and no coding. Candidates describe three parts: rating 60 to 111 statements from "strongly disagree" to "strongly agree", choosing the statement most and least like you from three, and picking what you would do in workplace scenarios. They report 4 days to finish, about 30 minutes of work, results in a day or two, a pass valid for 2 years, and a 6-month wait to reapply if you fail. Passing does not guarantee an interview.
  2. Resume and recruiter screen. A 10 to 15 minute call about your resume, projects, coding profiles and preferred language. One recruiter said its purpose was to check the candidate was genuine. New grads were asked for transcripts, and some US candidates had a visa-status call.

Scenario questions candidates reported in the hiring assessment: your boss rejected your idea; a friend's startup sells the tool you are buying; a colleague's work was credited to you at review time; a client sends you an expensive gift; a coworker offers code from their previous employer.

Candidate advice: read every statement slowly, because some pairs sound alike but mean different things; avoid "neutral"; and stay consistent, since contradicting yourself is the main red flag.

Stage 3: Online assessment or phone screen

How it works. Most candidates then get either a coding OA or a phone screen, sometimes both.

  • Online assessment: usually 2 coding questions in 60 to 90 minutes. Some OAs only show two basic test cases, so add your own. One 2026 OA on online coding platform allowed an AI assistant on some questions; practise with the sample question first. One 2025 intern OA had 15 multiple-choice questions plus 3 coding questions. Intern OAs in India were the hardest in our data, with tree and range-update problems.
  • Phone screen: one 45-minute coding round on a shared document, sometimes back to back with a behavioral round. It decides whether you reach the full loop.

At a glance

  • Length: 60 to 90 minutes
  • Questions per round: 2 coding questions (one 2025 intern OA had 15 multiple-choice questions plus 3 coding questions)
  • What was asked: greedy and DP on small boards, counting, and for interns tree DP and range updates
  • Most common: re-root a tree and XOR a subtree; the coin board and the shared-digit groups

OA questions candidates reported:

Question (our summary)What it testsLevel
Move tokens exactly 3 cells right on a board and collect the most coinsGreedy or DP on a stringSWE
Largest group of two-digit numbers that share a digitCountingSWE
Re-root a tree and XOR one subtree to get the largest totalTree DP, re-rootingIntern
Range additions, then the longest arithmetic-progression subsequenceSweep line + DPIntern
Build the string for a tree node from its children, or check it is a palindromeTree DFSIntern
Longest all-zero subarray with limited decrement and reset operationsBinary search + ordered setIntern
Count students in three score bands; days needed to read a book chapter by chapterArrays, simulationIntern
Find Median from Data StreamTwo heapsNew grad

More questions: Browse Google questions.

Google OA questions shared on Codinzhub:

QuestionDriveTopic
Maximum Count Above Threshold in a WindowIIIT AllahabadSliding window
Ticket Queue ScoreIIIT AllahabadQueue simulation
Tier Task Count SumIIIT AllahabadSorting, binary search
Ways to Split ArrayOff-campusPrefix max and suffix min
Concord Interval CensusOff-campusSubarray max minus min
Lighthouse Flag BroadcastOff-campusStrings
The Runner-Up Relay RouteOff-campusSecond shortest path
Convoy Load Balancing With Escort WeightOff-campusBinary search on the answer
Resonant Carrier Frequency QueueOff-campusSliding window
Datacenter Node Priority AssignmentGoogle Big CodeGraphs, components
Mountain Range Peak OptimizerGoogle Big CodeDP
Recursive Cache Amplification MaximizerGoogle Big CodeDP
Tricky SubarraysNot statedDP on permutations
Sum of FV for All Nodes in a TreeNot statedTree DFS
Tasty CakesNot statedDP

More Codinzhub questions: Browse Google questions.

At a glance

  • Length: 45 minutes, sometimes back to back with a behavioral round
  • Questions per round: 1 main problem plus 1 or 2 follow-ups
  • What was asked: tries, graphs, intervals, lowest common ancestor and grid DP
  • Most common: the HTTP router with parameters; course catalogue validation

Phone screen questions candidates reported:

Question (our summary)What it testsLevel
HTTP router with path parameters: register and look up handlersTrieSWE
Validate a course catalogue: missing courses and cyclesTopological sortSWE
Assign rental cars to bookings using the fewest carsIntervals, heapSWE
Closest common manager of K employees, then many queriesLowest common ancestorL4
Count ways to spell a word with periodic-table symbolsDPL4
Grid path from a mouse to cheese that stays as far from a cat as possibleBFS + binary searchSWE
Count paths across a grid, then through checkpoints, then in order with less memoryDPSWE
A range-tracking problem (identified by the candidate as Range Module)IntervalsL3
Maximum subarray, then a harder extensionKadane's algorithmSTEP intern

More questions: Browse Google questions.

Stage 4: The interview loop

How it works. Google runs the loop in two parts. R1 is a first virtual loop, usually one coding round and one Googleyness round. If it goes well, R2 is the onsite, two or three more coding rounds (in person again at several US offices in 2026). L5 and above add system design. Every round is 45 minutes, apart from some 60-minute design rounds.

What a 45-minute coding round looks like:

TimeWhat usually happensWhat you should do
0-5 minShort introduction, or none at all.Have a 30-second intro ready.
5-12 minA long, story-shaped or vague problem in a Google Doc.Restate it, ask about size, duplicates and ties, and agree on one example.
12-30 minYou explain and code.Brute force and its complexity first, then the better idea. Get a nod, then code while talking.
30-40 minFollow-ups that change one constraint.Adapt your code and give the new complexity.
40-45 minYour questions.Ask one real question about the team.

You cannot run the code, the interviewer types notes throughout, and the follow-ups usually decide the round.

R1, coding round

At a glance

  • Length: 45 minutes; some interviewers spend the first 10 on your resume
  • Questions per round: 1 problem plus 1 or 2 follow-ups
  • What was asked: heaps and streams, arrays, file-system trees and small class designs
  • Most common: no single question repeats; Find Median from Data Stream and the top-K message senders are typical

How it works. One problem with follow-ups, sometimes after a short resume discussion. One intern had a 10-minute grilling on past backend work first. Passing R1 is what gets you to the onsite.

Questions candidates reported:

Question (our summary)Follow-up reportedLevel
First Missing PositiveReduce space from O(n) to O(1)Intern
Find Median from Data StreamSmall value range; kth smallest insteadNew grad
Design a restaurant waitlistNot statedNew grad
The k users who sent the most messagesCompare heap, quickselect and sortingSWE
Total size of a file or directory by IDCheck the file system is validL4
Job queue with prioritiesEach job cools down for 3 callsL5
Visible nodes from the right side of a binary tree; k smallest pair sumsNoneSWE

More questions: Browse Google questions.

R1, Googleyness round

At a glance

  • Length: 45 minutes
  • Questions per round: 4 to 6 questions, each with 2 or 3 follow-ups
  • What was asked: conflict, priorities, ownership, feedback and team-lead hypotheticals
  • Most common: a disagreement with a coworker or another team

How it works. 45 minutes of behavioral questions, often on the same day as R1 coding. The interviewer takes notes and keeps digging into one theme with follow-ups. Some interviewers skip your resume; one senior candidate spent the whole round on a single project. It is scored, and several candidates who passed every coding round were rejected here.

Questions candidates reported:

  • A disagreement with a coworker, then with another team, then how you handle conflict in general.
  • A disagreement where you later found out you were wrong.
  • Different opinions that ended in a better design.
  • A tight deadline, several deadlines at once, more work than expected. Follow-up: why did that happen in the first place?
  • Someone took credit for your work.
  • As a team lead, what you do when someone misses a deadline or nobody knows the technology.
  • A junior you mentor will not listen.
  • Your biggest challenge, how you measured the result, and what you changed afterwards.
  • What you did to improve yourself this year.
  • Why Google, and what you will do if you do not pass this time.

More questions: Browse Google questions.

R2 and R3, onsite coding rounds

At a glance

  • Length: 45 minutes each, 2 or 3 rounds back to back (some L4 loops had 3 or 4 coding rounds in total)
  • Questions per round: 1 main problem and a chain of follow-ups; more of them ask you to design a class
  • What was asked: graphs, union-find, sliding windows, parsing, class design and some DP
  • Most common: the piano hand span; course prerequisites and topological sort

How it works. Two or three back-to-back coding rounds, harder than R1. Problems are longer and closer to real systems, and more of them ask you to design a class. L4 candidates sometimes had three or four coding rounds in total.

Questions candidates reported:

Question (our summary)What it testsLevel
Shortest path for Alice, then every node on any shortest path, then escaping BobBFSSWE
Earliest time every user is connected, from a connection logUnion-findSWE
Fewest hand lifts to play notes within a spanSliding windowL4
Fill strings from a key-value map, with nested keysParsing, recursionL4
Merge two trees of named nodes using one tree's order and the other's valuesTree recursionL4
Temperature monitor with moving average and O(1) maxDeque designL4
Shortest delivery route visiting every point on a gridBFS + bitmask DPL4
A maze with no feedback: one command list that exits from any startBFS over sets of cellsSWE
Largest rectangle from points, sides not parallel to the axesGeometry, hashingSWE
Maximum profit from non-overlapping jobsDP + binary searchSWE
Next-word predictor from training textHash map designSWE
Shortest path avoiding a broken nodeBFSSWE
Split a gold chain evenly by removing one linkPrefix sumsNew grad
Largest sum between two equal values, then in O(1) extra spacePrefix sumsNew grad
Longest water-flow path on a height gridDFS with memoNew grad
Mahjong winning hand; dictionary words with a prefixBacktracking; trieNew grad
Rank players from match resultsGraph reachabilityL4
Bookshelf with a bookmarkObject-oriented designL4
Cut the longest equal pieces from wooden boardsBinary search on answerL5
N-by-N tic-tac-toe for K playersClass designL5
Walk from the first row to the last in a 0/1 grid, then with weightsBFS, DijkstraL5
Python's tee iterator; a spreadsheet with set and getClass designL5+
snake_case to camelCase, then renaming a whole code base safelyStrings, open discussionL5+

More questions: Browse Google questions.

System design round (mostly L5 and above)

At a glance

  • Length: 45 to 60 minutes; 1 or 2 rounds (staff candidates had 2)
  • Questions per round: 1 design problem with follow-ups on scale
  • What was asked: requirements, data model, APIs, ranking, paging and trade-offs
  • Most common: no design repeats; a deals service, a web crawler and a rate limiter are typical

How it works. 45 to 60 minutes, one or two rounds. Staff candidates had two. Start with requirements and scale, then the data model, APIs and trade-offs. L3 and L4 loops in our data had no system design, though a few included an object-oriented design round.

Designs candidates reported: a deals service (weekly ingestion, ranking by browsing history, one claim per user, paged browsing); a customer-service agent that hands off to a human; a web crawler; a rate limiter for AI agents; log eviction; search autocomplete; offline sync.

More questions: Browse Google questions.

Stage 5: Hiring committee, team match and offer

How it works. After positive feedback, a hiring manager has to support you before your packet goes to the hiring committee. The committee can change your level: one L4 loop was approved at L3. Team matching follows, with one or more calls with hiring managers. It can be quick (one candidate was matched the day after the onsite) or slow (one staff candidate waited a month for the first call). At least one candidate passed every round and never matched with a team.

Google experiences shared on Codinzhub

Full-time experiences written up by candidates on Codinzhub. For intern experiences, see the intern guide.

CollegeRole and resultWhat was asked
IIT MadrasL3/L4 loop, offered L3R1: leaves with the largest root-to-leaf sum; the longest word that shrinks one letter at a time through the dictionary (memoised backtracking). R2: a hard maximum-total DP. R3: Googleyness. R4: DSA
IIT RoorkeeSDE, result pendingRoot an acyclic graph of degree at most 3 as a binary tree, then with colours alternating by level, then with three colours
Not statedSWE, result pendingFour rounds: minimum steps to 1 and longest palindromic substring; pattern search and a heap question; text justification, a skyline-style problem and clock angles; a DP problem and an alternating-colours shortest path

The Codinzhub Next-Round Playbook

What candidates who moved on actually did, stage by stage. Put together by the Codinzhub team from every Google experience in this guide.

To get past the hiring assessment

  • Answer as the colleague Google wants: collaborative, honest, calm under change. Pick strong agree or strong disagree for most statements.
  • Stay consistent. Several statements test the same trait in different words, and contradicting yourself is the main way people fail.
  • Read slowly. Some pairs differ by one word.

To get past the OA

  • Read every constraint before coding. Many OA questions hide a greedy or binary-search answer behind a long story.
  • Write your own test cases. Some OAs only show two basic ones.
  • If an AI assistant is allowed, try it on the sample first so you know what it is good for.

To get past the phone screen and R1 coding

  • Restate the problem and agree on one example before you write code.
  • Say the brute force and its complexity, then the better idea, and wait for a nod.
  • Keep talking while you code. One candidate with optimal code was rejected for lack of communication.
  • Leave five minutes to dry-run your own example. Candidates who found their own bug this way passed.

To get past Googleyness

  • Prepare six to eight real stories with numbers: conflict, shifting priorities, a mistake, helping someone, ambiguity, a project you are proud of.
  • Expect "why did that happen in the first place?" as a follow-up, and have the answer.
  • Treat it as scored. Candidates have cleared every coding round and still been rejected here.

To get past the onsite

  • Expect one main problem and several follow-ups. Finishing version one is the start, not the end.
  • Practise designing small classes (an iterator, a monitor, a router) and extending them live.
  • When an idea stops working, say so out loud. That is when interviewers give the hint that unlocks the problem.
  • Do not fall back to brute force once you have the better idea. Ask for help with the part you are stuck on.

To get through team matching

  • Reply quickly to recruiter and hiring-manager calls, and ask what the team works on.
  • Be patient: matching took from one day to over a month in these experiences.

How the loop differs by level

LevelWhat candidates describe
Intern and STEPA short recruiter call, an OA, then two 45-minute DSA rounds with two questions each. One 2027 intern prep session told candidates DP was not important. Topics named: arrays, math, sliding window, two pointers, prefix sums, hashing, binary search, stacks, queues, graphs and trees. A Googleyness round sometimes follows, and at least one intern was rejected there after strong coding rounds.
New grad (L3)An OA, then R1 (coding plus Googleyness), then an onsite with two coding rounds, then team matching. Reported problems include Find Median from Data Stream with follow-ups, a restaurant waitlist design, a water-flow path on a height grid, and a mahjong winning-hand check.
L4A phone screen or R1, then three or four coding rounds plus Googleyness. Expect long story-style graph problems and data-structure design with follow-ups. System design is rare at L4 in these reports. Rejections often cite communication or falling back to brute force.
L5, Senior and StaffTwo coding rounds, one or two system design rounds and a Googleyness round, which may spend 45 minutes on one project. Reported designs: a deals service, a customer-service agent with human escalation, a web crawler and a rate limiter. Hiring-manager support is needed before the hiring committee.

The question patterns that keep coming back

1. Graphs, BFS and DFS

The most common technical theme. Graphs usually arrive disguised as a grid, a social network, a course catalogue or a maze. Name the nodes and edges first, then choose BFS for the shortest number of steps, DFS for reachability, and union-find for groups that merge over time.

Reported examples: shortest path that avoids a broken node; the earliest time when every user is connected, from a connection log; course prerequisites and cycle detection (the most repeated question in our data); friend recommendations; and a maze with no feedback, where the state is the set of cells you might be in.

2. Trees and recursion

Tree problems often come wrapped in a story: an org chart, a file system or a config file. Decide what each node returns to its parent before you code.

Reported examples: the closest common manager of several employees (a lowest-common-ancestor variant); the total size of a directory; merging two trees of named nodes; zigzag and right-side-view traversals; maximum depth.

3. Arrays, strings, sliding windows and intervals

Reported examples: the fewest hand lifts to play piano notes within a span (sliding window); the most sum between two equal values in an array, then the same in O(1) extra space; meeting-room style counts that must also output every interval with exactly X overlaps; car rental assignment; string templating with nested keys; snake_case to camelCase, followed by how to rename a whole code base safely.

4. Design a small class

This is the most Google-specific style in the reports. You build a class with two or three methods, then the follow-ups change the requirements. It is still a DSA round: pick the data structures, state the invariants, give the complexity of every method.

Reported examples: an HTTP router with path parameters (a trie); a temperature monitor with moving average and O(1) max; a next-word predictor; a job queue with priorities and a cool-down; a spreadsheet with set and get; Python's tee iterator; a bookshelf with a bookmark; the most active user in a message log, then the top K.

5. Heaps, top K and streams

Reported examples: Find Median from Data Stream, then the kth smallest; the k users with the most messages (heap, quickselect and sorting compared); the k smallest pair sums from two arrays.

6. Binary search on the answer

If the question asks for the largest length, smallest capacity or minimum time that still works, binary search the answer and write a check function. Reported: cutting the longest equal pieces from wooden boards, and a cake-cutting problem.

7. Dynamic programming and backtracking

Less common than candidates fear. One candidate who spent weeks on DP was not asked any. When it appears: maximum profit job scheduling, counting ways to spell a word with periodic-table symbols, path counting on a grid with checkpoints, and a delivery route that visits every point (a small travelling-salesperson problem).

Preparing for Googleyness

The questions are listed under R1 above. Prepare six to eight stories from your own work, each under two minutes, with a measurable result. Expect two or three follow-ups on every story, and be ready to spend a whole round on one project and explain every trade-off in it.

A six-week plan

This assumes two to three focused hours a day. Interns can spend less time on DP and design; L5+ should add system design from week 2.

  1. Week 1: Arrays, strings, hashing and intervals. Two pointers, sliding window, prefix sums, sorting intervals. Write the complexity of every solution.
  2. Week 2: Trees and recursion. Traversals, lowest common ancestor, N-ary trees, tree problems told as stories. Say what each call returns before you code.
  3. Week 3: Graphs. BFS, DFS, topological sort, union-find, grid search. Draw the graph first.
  4. Week 4: Design a class, heaps and streams. Build an LRU cache, a trie router, a moving-average monitor and a top-K tracker. Add a follow-up to each yourself.
  5. Week 5: Binary search on the answer, DP and backtracking. Keep it to the basics unless you are full-time.
  6. Week 6: Mocks. Four timed 45-minute mocks in a plain Google Doc with no compiler. Each one should have at least two follow-ups. Prepare your Googleyness stories and rehearse them aloud.

Only two weeks? Spend five days on graphs and trees, three on arrays and intervals, two on class-design problems, and four on timed mocks and behavioral stories.

Practice problems that match these experiences

These are well-known practice problems chosen because the same pattern appears in these experiences. They are not claims about Google's question bank.

#Practice problemPatternSeen in these experiences as
1Course ScheduleTopological sortCourse catalogue validation
2Number of IslandsGrid BFS/DFSGrid path and reachability questions
3Graph Valid TreeUnion-findFile-system validity follow-up
4Lowest Common Ancestor of a Binary TreeTree DFSClosest common manager of many employees
5Binary Tree Zigzag Level Order TraversalBFSAsked as-is in one report
6Meeting Rooms IISweep lineMeeting-room and car-rental variants
7Find Median from Data StreamTwo heapsNew grad R1, with a kth-smallest follow-up
8Logger Rate LimiterHash map designOnsite design-a-class round
9Implement TrieTrieHTTP router with parameters
10Maximum Profit in Job SchedulingDP + binary searchAsked in one onsite
11Cutting RibbonsBinary search on answerL5 wood-cutting problem
12Shortest Word DistanceArraysL4 onsite variant with a class follow-up

How to handle a question you have never seen

  1. Repeat the problem and one example back. Many Google problems are long and vague on purpose.
  2. Say the brute force and its complexity. A correct slow answer beats five silent minutes.
  3. Name the bottleneck. Repeated lookups suggest a hash map, repeated ranges suggest prefix sums, and a repeated best item suggests a heap.
  4. Say when you are stuck. Interviewers in these reports usually helped once the candidate said what was not working.
  5. Code in small pieces and keep talking.
  6. Dry-run one case by hand, then fix the line that is wrong instead of restarting.

Why candidates were rejected

From the reports that gave a reason:

  • Lack of communication, even with optimal code.
  • Falling back to brute force after starting a better approach and getting stuck on the details.
  • Running out of time after a long clarification phase or a wrong first direction.
  • Code quality, raised in feedback even when the round passed.
  • A weak Googleyness round after strong coding.
  • Needing hints, which candidates felt counted against them, though some still passed.

If you remember only five things

  1. The loop is a hiring assessment, sometimes an OA, then about five 45-minute rounds. Coding dominates; Googleyness is scored.
  2. Each round is one problem plus follow-ups. Practise extending your own solutions.
  3. Agree on the approach before you code, and keep talking. Communication is a stated rejection reason.
  4. Graphs, trees and design-a-class problems are the core. DP matters less than its reputation.
  5. Practise in a Google Doc with no compiler, and dry-run every solution.

FAQ

Is there always an online assessment?

No. Many reports describe the work-style hiring assessment and a 2-question coding OA, but some experienced candidates went straight from a recruiter call to interviews.

Do I need dynamic programming?

Learn the basics. DP appears in a few reports, but one intern prep session said it was not important, and one candidate who studied it heavily was not asked any.

Is system design asked?

Mostly at L5 and above in these reports. L3 and L4 loops were coding and Googleyness, sometimes with a class-design or object-oriented flavour.

How long does it take?

It varies widely. Reports range from about three weeks to several months, with team matching often the slowest step.

Will the interviewer help me?

Usually, if you say where you are stuck. Most candidates described interviewers as friendly and willing to give hints.

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.

Disclaimer. Google's process changes by role, year and office. Use this guide to build a foundation, then confirm the current format with your recruiter.

Ready for the next topic?

Keep track of what you’ve learned.