Google Online Assessment 2026: OA & Phone Screen Guide

Quick answer (updated 8 June 2026): Google's early-stage screen for new-grad software roles in 2026 is usually either an online sample-coding assessment (one to two DSA problems, auto-graded) or a recruiter-arranged technical phone screen with a live coder, depending on the cohort and region. Difficulty is medium to hard, with a strong emphasis on optimal solutions and clear reasoning. The pattern below is compiled from 2023 to 2025 candidate reports, not an official spec, so confirm the format and timing with your recruiter and the invite from Google's careers portal.

Google's first filter is brutal because it screens for the same bar as the onsite: optimal code and clear thinking. Whether you get an auto-graded OA or a live phone screen, the prep is the same. This guide covers both, with worked solutions.

Two Entry Formats at Google

Candidate reports for 2023 to 2025 describe two main early screens, depending on cohort:

Format is candidate-reported (2023 to 2025) and varies by region, role, and recruiting channel. Your recruiter and invite email confirm which one you will take.

Some candidates skip a separate OA entirely and go straight to a phone screen via referral or campus channels. Others complete an auto-graded sample coding assessment first. Either way, the topics and bar are the same.

Topics That Repeat in the Google Screen

Compiled from candidate reports across 2023 to 2025; relative frequency, not an official syllabus:

Relative frequencies from candidate aggregates (2023 to 2025), labelled approximate. Google skews harder than typical service-company OAs.

Worked Solution 1: Hashing

Problem: Given an array of strings, group the anagrams together.

Approach: Use a sorted-string key (or a character-count signature) to bucket anagrams in a hash map.

from collections import defaultdict

def group_anagrams(words):
    groups = defaultdict(list)
    for w in words:
        key = ''.join(sorted(w))
        groups[key].append(w)
    return list(groups.values())

Complexity: O(n times k log k) where k is the max word length (the sort dominates). The count-signature variant is O(n times k) and a good follow-up answer when the interviewer asks to remove the sort.

Worked Solution 2: Two-Pointer

Problem: Given a sorted array, return all unique triplets that sum to zero.

Approach: Fix one element, then use two pointers on the rest to find pairs summing to its negation. Skip duplicates to keep triplets unique.

def three_sum(nums):
    nums.sort()
    result = []
    n = len(nums)
    for i in range(n - 2):
        if i > 0 and nums[i] == nums[i - 1]:
            continue
        lo, hi = i + 1, n - 1
        while lo < hi:
            total = nums[i] + nums[lo] + nums[hi]
            if total == 0:
                result.append([nums[i], nums[lo], nums[hi]])
                while lo < hi and nums[lo] == nums[lo + 1]:
                    lo += 1
                while lo < hi and nums[hi] == nums[hi - 1]:
                    hi -= 1
                lo += 1
                hi -= 1
            elif total < 0:
                lo += 1
            else:
                hi -= 1
    return result

Complexity: O(n squared) time, O(1) extra space beyond output. Google probes the duplicate-skipping carefully, so be precise with the inner while loops.

Worked Solution 3: Trees

Problem: Given a binary tree, return its right-side view (the nodes visible from the right).

Approach: Level-order BFS, recording the last node of each level.

from collections import deque

def right_side_view(root):
    if not root:
        return []
    view = []
    q = deque([root])
    while q:
        size = len(q)
        for i in range(size):
            node = q.popleft()
            if i == size - 1:
                view.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
    return view

Complexity: O(n) time, O(w) space for the widest level. A DFS variant tracking depth also works and is a clean follow-up.

Worked Solution 4: Dynamic Programming

Problem: Given a grid where each cell has a cost, find the minimum-cost path from top-left to bottom-right, moving only right or down.

Approach: DP over the grid; each cell's cost is its own value plus the cheaper of the cell above or to the left.

def min_path_sum(grid):
    rows, cols = len(grid), len(grid[0])
    dp = [[0] * cols for _ in range(rows)]
    dp[0][0] = grid[0][0]
    for r in range(rows):
        for c in range(cols):
            if r == 0 and c == 0:
                continue
            up = dp[r - 1][c] if r > 0 else float('inf')
            left = dp[r][c - 1] if c > 0 else float('inf')
            dp[r][c] = grid[r][c] + min(up, left)
    return dp[rows - 1][cols - 1]

Complexity: O(rows times cols) time and space. The space can drop to O(cols) with a rolling row, which Google interviewers often ask for as an optimisation.

Strategy for the Auto-Graded OA

1. Read constraints to infer complexity. Large n demands sub-quadratic; this is your biggest clue.
2. Aim for optimal, not just passing. Google's bar rewards the efficient solution even in auto-graded form.
3. Exploit partial scoring where present. Submit a working solution, then optimise.
4. Test edge cases. Empty, single element, duplicates, and extreme values catch most bugs.
5. Watch the clock. Two hard problems in limited time means you must pace strictly.

Strategy for the Live Phone Screen

1. Clarify the problem first. Ask about input ranges, edge cases, and expected output.
2. State your approach and complexity before coding. GCA is scored on your reasoning.
3. Code in the shared doc cleanly. No autocomplete; write correct, readable code.
4. Dry-run on an example. Catch your own bugs before the interviewer does.
5. Use hints well. The interviewer steers; respond and improve.

How to Prepare for the Google Screen

• Drill the high-frequency patterns to optimal complexity: hashing, two-pointer, trees, graphs, DP, backtracking, intervals.
• Practise live, talking out loud, since the phone screen scores communication as much as code.
• Do timed mock OAs with hard problems to match Google's difficulty.
• Learn to state complexity automatically for every solution.

See How to prepare Google coding interview 2026 and Google placement syllabus 2026.

Why the Google Screen Feels Harder Than Most

Candidates who have cleared other companies' online assessments are often surprised by Google's screen, and understanding why helps you calibrate your preparation. The difference is not that Google asks exotic topics; it asks the same core patterns as everyone else. The difference is the bar for what counts as a passing answer. Where a service company may accept a working solution regardless of complexity, Google's screen, whether the auto-graded sample assessment or the live phone screen, expects the optimal solution with correct complexity analysis, because it is screening for the same bar as the onsite loop.

This shows up in two ways. First, the hidden test cases in the auto-graded format are sized so that a brute-force solution times out, which means a correct-but-slow answer can still fail. You have to recognise, from the constraints, when a quadratic approach will not survive and reach for the linear or log-linear technique instead. Second, in the live phone screen, the interviewer scores your General Cognitive Ability, how you reason, structure the problem, and respond to hints, so even a correct answer delivered in silence underperforms a well-narrated one. The screen is a genuine preview of the onsite, not a lighter filter.

The practical preparation, therefore, is depth over breadth and optimality over mere correctness. Take the high-frequency patterns, hashing, two-pointer, trees, graphs, dynamic programming, intervals, and backtracking, and drill them until you can produce the optimal solution and state its complexity automatically. Then practise out loud, ideally in mock interviews, so that narrating your reasoning is second nature. A candidate who consistently reaches the optimal solution and explains it clearly will find the Google screen demanding but fair, while one who stops at brute force or codes silently will find it frustrating.

More Worked Solutions

Worked Solution 5: Product of Array Except Self

Return an array where each element is the product of all others, without division, using prefix and suffix passes.

def product_except_self(nums):
    n = len(nums)
    res = [1] * n
    prefix = 1
    for i in range(n):
        res[i] = prefix
        prefix *= nums[i]
    suffix = 1
    for i in range(n - 1, -1, -1):
        res[i] *= suffix
        suffix *= nums[i]
    return res

Time O(n), space O(1) extra. The no-division constraint and the two-pass trick make this a Google favourite.

Worked Solution 6: Valid Parentheses (Stack)

Balanced-bracket check with clean edge handling.

def is_valid(s):
    pairs = {')': '(', ']': '[', '}': '{'}
    stack = []
    for ch in s:
        if ch in '([{':
            stack.append(ch)
        elif not stack or stack.pop() != pairs[ch]:
            return False
    return not stack

Time O(n), space O(n).

Worked Solution 7: Course Schedule (Topological Sort)

Detect whether all courses can be finished using Kahn's algorithm.

from collections import deque, defaultdict

def can_finish(n, prereqs):
    graph = defaultdict(list)
    indeg = [0] * n
    for a, b in prereqs:
        graph[b].append(a)
        indeg[a] += 1
    q = deque(i for i in range(n) if indeg[i] == 0)
    seen = 0
    while q:
        u = q.popleft()
        seen += 1
        for v in graph[u]:
            indeg[v] -= 1
            if indeg[v] == 0:
                q.append(v)
    return seen == n

Time O(V + E).

Why Candidates Fall Short in the Google Screen

Candidate reports point to recurring reasons strong candidates do not pass:

• Brute force only. Google's screen expects optimal solutions with correct complexity, even when auto-graded.
• Misreading constraints. Large inputs demand sub-quadratic solutions; ignoring this causes time-outs.
• Silent solving in the phone screen. General Cognitive Ability is scored on your reasoning, so narrate.
• Weak edge-case handling. Empty, single element, duplicates, and extreme values are common failure points.
• Poor pacing. Two hard problems in limited time means strict per-problem time budgets.

Preparation Timeline (8 to 10 Weeks)

• Weeks 1 to 2: Foundations to optimal. Arrays, two-pointer, sliding window, hashing at optimal complexity.
• Weeks 3 to 5: Trees and graphs. Traversals, BFS, DFS, topological sort, and connectivity.
• Weeks 6 to 7: DP, intervals, backtracking. Subsequence, partition, merge intervals, combinations.
• Weeks 8 to 10: Mocks. Timed hard-problem mock OAs and live phone-screen mocks narrating out loud.

Related Resources

• Google coding interview rounds 2026, the full onsite loop after the screen
• Google off campus drive 2026, the 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 placement syllabus 2026, topic coverage

FAQs: Google Online Assessment 2026

Q: Does Google have an online assessment or a phone screen first?

Candidate reports describe both depending on cohort and region: some take an auto-graded online sample coding assessment, others go straight to a recruiter-arranged technical phone screen, often via referral or campus channels. Your recruiter confirms which applies to you.

Q: How hard are Google OA problems?

Medium to hard, harder than typical service-company OAs. Google expects optimal solutions with correct complexity analysis, not just passing brute force. Prepare the high-frequency patterns to their optimal forms.

Q: How long is the Google online assessment?

Candidate reports cite roughly 60 to 90 minutes for one to two problems in the auto-graded format, and around 45 minutes for a live phone screen. Your invite email gives the exact timing.

Q: Can I use any language in the Google screen?

For auto-graded OAs, common languages like C++, Java, and Python are typically offered. In the live phone screen you write in a shared document, so choose the language you are most fluent in and can write correctly without autocomplete.

Q: Do I need to talk through my solution in the phone screen?

Yes. General Cognitive Ability is scored on how you reason, so clarify the problem, state your approach and complexity, and narrate as you code. Silent solving loses signal even with correct code.

Q: What topics should I prioritise for the Google screen?

Arrays and strings, hashing, trees and graphs, dynamic programming, recursion and backtracking, and intervals, all at optimal complexity. Google skews toward graphs, DP, and clever optimisations, so go beyond brute force.

Q: Why is the Google screen harder than other companies' OAs?

Not because it asks exotic topics, but because the bar for a passing answer is higher. Google expects the optimal solution with correct complexity, and the hidden tests are sized so a brute force times out. It is a genuine preview of the onsite bar, not a lighter filter.

Q: Can I skip the OA and go straight to a phone screen at Google?

Some candidates do, via referral or campus channels, while others take an auto-graded sample assessment first. Both lead to the same onsite loop and test the same bar. Your recruiter confirms which path applies to you.

Q: How do I prepare for the live phone screen specifically?

Practise solving out loud in a plain shared document without autocomplete, clarifying the problem first, stating your approach and complexity, and narrating as you code. Do mock phone screens where someone gives hints, since using hints well is scored positively.