Google Coding Interview Rounds 2026: Loop + Rubric

Quick answer (updated 8 June 2026): Google's new-grad software engineering interview in 2026 typically runs: an online assessment or phone screen, then an onsite loop of four to five interviews, mostly DSA coding with one Googleyness-and-leadership round. Crucially, your interviewer does not decide; an independent hiring committee reviews the written feedback and makes the call. Google scores on four signals: General Cognitive Ability, Role-Related Knowledge, Leadership, and Googleyness. The structure below is compiled from 2023 to 2025 candidate reports, not an official document, so confirm your specific loop with your recruiter.

Google's interview is famous for being hard, but it is also one of the most structured. Once you understand that the hiring committee, not your interviewer, makes the decision, your strategy changes. This guide breaks down every round and how to actually score.

The Google Hiring Funnel

Based on candidate reports for 2023 to 2025 new-grad batches:

Stages and counts are candidate-reported (2023 to 2025) and vary by level and region. Your recruiter and scheduling email are binding for your loop.

The two facts that make Google different: your interviewers write detailed feedback but do not make the decision, and you must clear the hiring committee, then separately match to a team. A strong loop with no team match can stall, which is why team-match prep matters too.

The Four Scoring Signals

Every Google interviewer scores you against four attributes. Knowing them lets you target your answers:

1. General Cognitive Ability (GCA): how you solve novel problems, structure your thinking, and handle ambiguity.
2. Role-Related Knowledge (RRK): your DSA, coding, and (for some levels) design depth.
3. Leadership: how you take ownership, navigate ambiguity, and influence, even as a fresher.
4. Googleyness: comfort with ambiguity, intellectual humility, collaboration, and bias to action.

For new grads, GCA and RRK carry most of the coding-round weight, while Leadership and Googleyness are probed in the dedicated behavioural round.

The Coding Rounds (the core of the loop)

Four of the five onsite rounds are typically DSA coding. Google's bar is high: clean, optimal solutions with crisp complexity analysis and strong communication.

What Google interviewers reward, per candidate reports:

• Optimal complexity. A brute force is a starting point, not an acceptable final answer at Google's bar. State it, then optimise.
• Clear thinking out loud. GCA is scored on your process; silent coding loses signal.
• Correct, runnable code. Interviewers may ask you to trace through inputs; off-by-one bugs hurt.
• Communication under hints. Interviewers nudge; using a hint well is positive, ignoring it is negative.
• Edge-case rigour. Empty input, single element, overflow, duplicates.

Google leans toward problems on arrays and strings, hashing, trees, graphs, recursion and backtracking, dynamic programming, and intervals.

Worked Solution 1: Graphs (BFS)

Problem: Given a grid where 0 is empty, 1 is fresh, and 2 is rotten, each minute rotten cells rot adjacent fresh cells. Return the minutes until none are fresh, or -1 if impossible.

Approach: Multi-source BFS from all rotten cells simultaneously, counting levels until the queue empties; then check for any remaining fresh cells.

from collections import deque

def oranges_rotting(grid):
    rows, cols = len(grid), len(grid[0])
    q = deque()
    fresh = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 2:
                q.append((r, c))
            elif grid[r][c] == 1:
                fresh += 1
    minutes = 0
    dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)]
    while q and fresh:
        minutes += 1
        for _ in range(len(q)):
            r, c = q.popleft()
            for dr, dc in dirs:
                nr, nc = r + dr, c + dc
                if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 1:
                    grid[nr][nc] = 2
                    fresh -= 1
                    q.append((nr, nc))
    return minutes if fresh == 0 else -1

Complexity: O(rows times cols) time and space. Multi-source BFS is a signature Google pattern; recognising "spread from many starts at once" is the key insight.

Worked Solution 2: Dynamic Programming

Problem: Given a string and a dictionary of words, determine if the string can be segmented into a space-separated sequence of dictionary words.

Approach: Bottom-up DP. dp[i] is true if the prefix of length i is segmentable. For each i, check every split point j where dp[j] is true and the substring j..i is a word.

def word_break(s, word_dict):
    words = set(word_dict)
    n = len(s)
    dp = [False] * (n + 1)
    dp[0] = True
    for i in range(1, n + 1):
        for j in range(i):
            if dp[j] and s[j:i] in words:
                dp[i] = True
                break
    return dp[n]

Complexity: O(n squared) substring checks (or better with a trie). Google interviewers often ask you to also return the actual segmentation, which extends this with backtracking.

Worked Solution 3: Intervals

Problem: Given a set of intervals, merge all overlapping ones.

Approach: Sort by start. Walk through; if the current interval overlaps the last merged one, extend it, otherwise start a new merged interval.

def merge_intervals(intervals):
    intervals.sort(key=lambda x: x[0])
    merged = []
    for start, end in intervals:
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

Complexity: O(n log n) time for the sort, O(n) space. Interval problems (insert, merge, overlap-count) recur at Google; the sort-then-sweep template covers most.

Worked Solution 4: Backtracking

Problem: Given a string of digits, return all possible letter combinations the number could represent on a phone keypad.

Approach: Depth-first backtracking, building combinations digit by digit.

def letter_combinations(digits):
    if not digits:
        return []
    mapping = {'2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl',
               '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz'}
    result = []

    def backtrack(index, path):
        if index == len(digits):
            result.append(''.join(path))
            return
        for ch in mapping[digits[index]]:
            path.append(ch)
            backtrack(index + 1, path)
            path.pop()

    backtrack(0, [])
    return result

Complexity: O(4^n times n) in the worst case (digits mapping to four letters). Google probes whether you can reason about the size of the solution space, so state it explicitly.

The Googleyness and Leadership Round

One round is dedicated to behaviour, scoring Leadership and Googleyness. Common prompts from candidate reports:

• Tell me about a time you dealt with ambiguity.
• Describe a disagreement and how you handled it.
• Tell me about a project you drove yourself.
• Describe a time you failed and what you learned.
• How do you handle feedback you disagree with?

Answer with real STAR examples. Google looks for intellectual humility (you can say "I do not know, here is how I would find out"), comfort with ambiguity, and collaboration over ego.

How to Prepare for the Google Loop

• DSA depth: master graphs (BFS/DFS, multi-source, topological sort), DP, intervals, backtracking, and trees at the optimal complexity, not just brute force.
• Communication: practise narrating and stating complexity for every problem; record yourself.
• Hint handling: do mock interviews where someone gives hints; learn to use them gracefully.
• Behavioural: prepare STAR stories that show ambiguity, ownership, failure, and collaboration.
• Team match: keep a tight, honest resume of projects so recruiters can place you fast after the committee clears you.

Pair this with How to prepare Google coding interview 2026.

Eligibility and Key Dates (Reference)

Google hires new-grad software engineers through campus channels, referrals, and rolling careers-portal openings. The reference criteria below are compiled from candidate reports for 2023 to 2025 cycles and vary by role; the binding eligibility is whatever the specific job notification on Google's careers portal states.

Eligibility figures are candidate-reported references (2023 to 2025), not official cutoffs. Google opens new-grad roles in rolling windows; watch its careers portal and verified channels for live openings and dates. The job notification is binding.

More Worked Solutions

Worked Solution 5: Clone a Graph (BFS plus Hashing)

Deep-copy a connected undirected graph, mapping originals to clones to avoid infinite loops.

from collections import deque

def clone_graph(node):
    if not node:
        return None
    clones = {node: Node(node.val)}
    q = deque([node])
    while q:
        cur = q.popleft()
        for nb in cur.neighbors:
            if nb not in clones:
                clones[nb] = Node(nb.val)
                q.append(nb)
            clones[cur].neighbors.append(clones[nb])
    return clones[node]

Time O(V + E). The visited map doubles as the original-to-clone mapping, a clean Google-style insight.

Worked Solution 6: Trapping Rain Water (Two Pointer)

Compute trapped water using two pointers tracking the running max from each side.

def trap(height):
    left, right = 0, len(height) - 1
    left_max = right_max = water = 0
    while left < right:
        if height[left] < height[right]:
            left_max = max(left_max, height[left])
            water += left_max - height[left]
            left += 1
        else:
            right_max = max(right_max, height[right])
            water += right_max - height[right]
            right -= 1
    return water

Time O(n), space O(1). A Google favourite that rewards the O(1)-space two-pointer insight over the O(n)-space prefix arrays.

Worked Solution 7: Kth Smallest in a BST (In-order)

In-order traversal of a BST yields sorted order; stop at the kth element.

def kth_smallest(root, k):
    stack = []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        k -= 1
        if k == 0:
            return root.val
        root = root.right

Time O(h + k), space O(h). The iterative in-order avoids fully traversing the tree.

Why Candidates Fall Short in Google Loops

Candidate reports point to recurring reasons strong candidates do not clear the bar:

• Stopping at brute force. Google expects the optimal solution with correct complexity; a brute force alone rarely passes.
• Silent coding. General Cognitive Ability is scored on how you think out loud; not narrating loses signal.
• Ignoring hints. Interviewers steer deliberately; resisting a useful nudge reads as inflexibility.
• Inconsistent rounds. Because the hiring committee weighs all feedback, one weak round can sink an otherwise strong loop.
• Neglecting Googleyness. Treating the behavioural round as filler underperforms; humility and collaboration are scored.

Preparation Timeline (8 to 10 Weeks)

• Weeks 1 to 2: Foundations to optimal. Arrays, two-pointer, sliding window, hashing, solved at optimal complexity with narration.
• Weeks 3 to 5: Graphs and trees. BFS, DFS, multi-source BFS, topological sort, BST operations, and clone-graph style problems.
• Weeks 6 to 7: DP, intervals, backtracking. Word break, edit distance, merge intervals, combinations, with space optimisations.
• Weeks 8 to 10: Mocks and behaviour. Live mock interviews with hints, plus STAR stories for Googleyness and Leadership.

Related Resources

• Google online assessment 2026, the OA and phone-screen gate before the loop
• Google off campus drive 2026, the full hiring cycle and eligibility
• How to prepare Google coding interview 2026, the prep companion
• LeetCode questions Google 2026, curated problem set
• Google placement papers 2026, solved past-drive papers
• Google SDE fresher salary India 2026, package breakdown

FAQs: Google Coding Interview Rounds 2026

Q: How many interview rounds does Google have for new grads?

Candidate reports for 2023 to 2025 describe an onsite loop of four to five interviews after an online assessment or phone screen, mostly DSA coding with one Googleyness-and-leadership round. Your recruiter confirms your specific loop.

Q: Who decides whether I get a Google offer?

Not your interviewers. They write detailed feedback, and an independent hiring committee reviews the full packet to make the hire or no-hire call. This is why consistent, well-communicated performance across all rounds matters more than impressing any single interviewer.

Q: What are the four signals Google scores?

General Cognitive Ability (problem-solving), Role-Related Knowledge (DSA and coding depth), Leadership, and Googleyness (humility, comfort with ambiguity, collaboration). For new grads, GCA and RRK dominate the coding rounds.

Q: Do I need optimal solutions to pass Google interviews?

Effectively yes at Google's bar. State the brute force to show you see the problem, then move to the optimal solution with correct complexity analysis. Stopping at brute force is generally not enough for a strong score.

Q: What is team match at Google?

After the hiring committee approves you, a recruiter pairs you with a specific team that has an opening. A strong loop with no available team match can delay your offer, so keep your project profile clear and stay responsive during this phase.

Q: How important is communication in Google coding rounds?

Critical. General Cognitive Ability is scored on how you think out loud, structure the problem, and use hints. Silent coding loses signal even if your final code is correct, so narrate throughout.

Q: Is a brute-force solution ever acceptable at Google?

Only as a starting point. State the brute force to show you understand the problem, then move to the optimal solution with correct complexity analysis. Stopping at brute force generally does not meet Google's bar for Role-Related Knowledge.

Q: How should I handle a hint from a Google interviewer?

Take it gracefully and incorporate it. Interviewers steer deliberately, and using a hint well is a positive signal, while ignoring or resisting one reads as inflexibility. Treat the interview as collaborative problem-solving, not a solo test.

Q: What happens if I clear the loop but there is no team match?

Your offer can stall until a suitable team with an opening is found, since Google separates the hiring-committee decision from team match. Keep your project profile clear and stay responsive during this phase to speed up placement.