Google's online assessment is an early screening step that not every candidate gets. Google's own hiring page says you may be asked to take the Google Hiring Assessment, which measures workstyle skills, and, where the role calls for it, a role-related test such as a coding exercise. For software engineering interns and new grads, candidates most often report two data structures and algorithms problems in a window of roughly 60 to 90 minutes, pitched around LeetCode easy to medium.
Google does not publish a fixed format, so this guide separates what Google states officially from what candidates commonly report. One rule applies throughout: the assessment measures your own skills, so take it on your own and under whatever conditions your invitation sets.
What Google officially says
Google's “How we hire” page describes a process that typically takes about six to eight weeks and may include some or all of these steps:
- Assessments. Before interviews you may be asked to take the Google Hiring Assessment, which measures workstyle, plus role-related assessments such as a coding exercise when they apply to the job.
- Recruiter conversations. Usually one or two shorter phone or video calls that check key skills and cover preferences such as location.
- Project work. Some roles ask for a small project, such as a case study, a writing sample or a code sample, before interviews.
- Interviews. A panel of structured interviews scored against shared rubrics, over video or in person. Google's interview tips page adds that it has reintroduced in-person interviews for some roles, often after initial rounds held virtually.
Three other official points matter for assessment prep. Google reviews transcripts as well as résumés for interns and new graduates. It offers accommodations, including extended time, through your recruiter, so ask before you start rather than after. And it states plainly that AI tools are not permitted during interviews.
Who gets a Google online assessment
Practice varies by role, level, region and recruiting cycle. Based on Google's guidance and candidate reports, the pattern looks like this:
| Candidate | Coding assessment | Hiring Assessment | Usual next step |
|---|---|---|---|
| SWE intern (BS/MS) | Commonly reported, though some candidates, including some referrals, report skipping it | Reported by some candidates | Technical interviews, then team (host) matching |
| New grad / early career | Commonly reported | Reported by some candidates | Recruiter call, then technical interviews |
| Experienced (L4 and above) | Not typically reported; most move to a live technical screen | Reported for some levels, including L4 | Recruiter call, technical phone screen, interview loop |
If you are unsure which steps apply to you, ask your recruiter. Your invitation and your recruiter are the authority on format, deadline and rules, and they override anything you read online, including this page.
The coding assessment, as candidates report it
| Element | What candidates commonly report |
|---|---|
| Problems | Two coding problems is the most common report; one prep guide says one or two. |
| Time | Roughly 60 to 90 minutes. Ninety minutes is a common planning assumption, but the limit in your invitation is the one that counts. |
| Difficulty | LeetCode easy to medium in most reports, and generally easier than the interviews that follow. |
| Topics | Arrays, strings, hash maps, sorting, two pointers and stacks most often; trees, graphs and dynamic programming in some reports. |
| Test cases | Reports differ: some candidates had to write their own test cases, others did not. |
| Platform | Varies by cycle and region. One prep guide names HackerRank or Codility; many reports do not name a platform. |
Treat every line as a range, not a promise. These details come from self-reported threads and prep sites, they disagree on details such as timing and whether you write your own tests, and Google can change its process between cycles.
The Google Hiring Assessment
The Hiring Assessment is not a coding test. Google describes it as a measure of the workstyle skills a role needs. Everything beyond that comes from prep guides and candidate reports, and they disagree on length: one guide puts it at around 50 questions and 30 to 45 minutes, another at 50 to 75 questions, and a third at 75 to 105 statements over 30 to 60 minutes. Commonly reported features:
- Statement ratings on a five-point agree/disagree scale about how you work.
- Workplace scenarios, where you choose how you would respond to situations that touch on working style and ethics.
- No going back. Candidates commonly describe one item per screen with no way to return to earlier answers.
- A pass/fail result. Two prep guides report that a fail brings a waiting period of about six months, though they note policies can differ by role and region.
Preparation here is reflection, not study. Answer honestly and consistently; questionnaires like this often return to the same theme in different wordings, so trying to guess the “right” answer tends to produce contradictions. Take it in one quiet, uninterrupted sitting and read each item fully before you answer, since you reportedly cannot revise it later. The same reflection also gives you raw material for the behavioral questions later in the process.
Practice problems that match the reported style
Google does not publish its assessment questions, and none of the problems below are claimed to be on the test. They are well-known LeetCode problems that train the topics candidates most often report, sized to the easy-to-medium range.
| Topic | Practice problems | What it trains |
|---|---|---|
| Hash maps and counting | Two Sum, Contains Duplicate II, Group Anagrams | Constant-time lookups and counting inside a window |
| Strings and two pointers | Valid Palindrome II, 3Sum | Pointer movement and edge cases |
| Sliding window | Longest Substring Without Repeating Characters, Minimum Size Subarray Sum | Variable-length windows |
| Stacks | Valid Parentheses, Daily Temperatures | Matching and monotonic stacks |
| Sorting and intervals | Merge Intervals, Non-overlapping Intervals | Sort first, then sweep |
| Binary search | Binary Search, Koko Eating Bananas | Searching sorted data and searching on the answer |
| Grids and graphs | Number of Islands, Rotting Oranges | BFS and DFS on a grid |
| Trees | Maximum Depth of Binary Tree, Path Sum II | Recursion and path tracking |
| Dynamic programming | Climbing Stairs, Coin Change | Writing a recurrence, then memoizing it |
Once these feel routine, group further practice by technique rather than by company. Our 15 core LeetCode patterns guide maps each pattern to the clues in a problem statement that signal it.
A two-week preparation plan
Two weeks is enough if you already know one language well and the core data structures. Stretch the same plan to four weeks if you are starting closer to scratch.
- Days 1–3: Fundamentals. Arrays, strings, hash maps, sorting and two pointers. Three to four problems a day, untimed, aiming for clean, correct code.
- Days 4–6: Common patterns. Sliding window, stacks, binary search and intervals. Start timing yourself at about 25 minutes per medium.
- Days 7–9: Trees and graphs. Recursion on trees, BFS and DFS on grids, and basic heap problems.
- Days 10–11: Dynamic programming basics. One-dimensional and simple grid DP. Write the recurrence in a comment before writing any code.
- Days 12–13: Full simulations. Two unseen problems, 90 minutes, no notes and no searching, with your own tests written before you submit. Do at least two sets, and one at 60 minutes as a stretch.
- Day 14: Light review and logistics. Re-solve three problems you missed earlier, check your setup, and reread the rules in your invitation.
Practice the format, not just the problems. Solving one untimed problem at a time trains a different skill from clearing two unseen problems against a clock with no one to ask. Our new grad online assessment guide covers how timed, auto-graded tests reward finishing over elegance.
How to approach the test on the day
- Read both problems first. Spend a couple of minutes on each prompt, then start with the one you can finish fastest.
- Let the constraints pick the algorithm. Input sizes around 105 usually rule out O(n²) and point toward O(n log n) or O(n). The free Big-O complexity visualizer shows how quickly each class grows.
- Get a correct solution first. A brute force that passes small cases is a foundation. Optimize once it works, if time allows.
- Test your own code. Try empty input, a single element, duplicates, negative numbers and the largest allowed size before you submit.
- Budget the clock. With two problems in 90 minutes, aim for about 40 minutes each and keep 10 minutes for review.
- Use your strongest language. Fluency matters more than range.
- Set up properly. A quiet room, a stable connection and a charged laptop. Request any accommodation before you begin.
Above all, complete the assessment on your own under the employer's rules: no outside help, no AI tools and no second person, unless your invitation explicitly allows something. Google says AI tools are not permitted in its interviews, and breaking a stated rule can end a candidacy outright, which costs far more than a weak score.
What happens after the assessment
Response times in candidate reports range from a few days to several weeks, and Google does not publish an official turnaround. If you move forward:
- Interns typically report two technical interviews, which one prep guide puts at 45 to 60 minutes each, then team matching, often called host matching. Some candidates report a third interview when earlier feedback is mixed. Our Google SWE internship interview guide covers both stages.
- New grads typically report recruiter conversations, technical interviews and a behavioral round. The Google new grad interview process walks through each one.
- Experienced candidates rarely report a coding test; they describe a recruiter call, a technical phone screen and then the full interview loop. Our Google software engineer interview process guide covers each stage.
Expect the interviews to be harder than the assessment, and spoken. You will explain your approach out loud while you code, which is a different skill from solving in silence. A free AI mock interview in CoPilot Interview lets you rehearse that: it reads questions aloud, listens to your spoken answer and scores it with what worked and what to improve.
If you do not pass, it is not a permanent mark. Google notes that most Googlers applied for other roles before they reached interviews, and you can apply for up to three roles in any 30-day window.
Get ready for the rounds after the OA
Passing the assessment leads to live, spoken interviews. CoPilot Interview's free AI mock interview builds questions from your résumé and a job description, reads them aloud and scores each answer, with 15 minutes a day free and no credit card.
Try a free AI mock interviewFAQ
Does every Google applicant get an online assessment?
No. Google says you may be asked to take an assessment before interviews. Coding assessments are most commonly reported for intern and new grad software roles, while experienced candidates and some referrals report skipping the coding test and going to recruiter calls and interviews.
How long is the Google online assessment?
Candidates most often report two coding problems in a window of roughly 60 to 90 minutes. Google does not publish a fixed format, so your invitation is the authority on timing.
How hard is the Google online assessment?
Most candidate reports put it at LeetCode easy to medium, and generally easier than the technical interviews that follow. Prepare at the medium level so the real test feels manageable.
What is the Google Hiring Assessment?
It is a workstyle questionnaire Google may ask you to complete before interviews. Candidates and prep guides describe agree/disagree statement ratings and workplace scenarios rather than coding, so answer honestly and consistently.
Can I use AI tools or notes during the Google online assessment?
No. Complete it on your own under the rules in your invitation. Google states that AI tools are not permitted in its interviews, and breaking a stated rule can end your candidacy.
What happens after I pass the Google online assessment?
Intern candidates typically report two technical interviews and then team matching, often called host matching. New grad candidates typically report recruiter conversations, technical interviews and a behavioral round, with response times that range from days to weeks.