Google's software engineer interview process for experienced hires usually runs in this order: application, one or two recruiter calls, an online Google Hiring Assessment for some candidates, one or two technical screens of 45 to 60 minutes, a loop of about four to six interviews (coding, system design from L5 up, and a Googleyness and Leadership round), then a hiring committee review, team matching (the order of these two varies) and an offer. Google says the process typically takes roughly six to eight weeks once interviews start, and every interview is scored against shared rubrics.
This guide covers that whole path for engineers with industry experience. Students and recent graduates should start with the Google new grad interview process guide; if you are targeting L4, pair this page with how to crack the Google L4 interview. Google adjusts its process between hiring seasons, so where public accounts differ we say so, and your recruiter's instructions always win.
The process at a glance
| Stage | Format | What it decides |
|---|---|---|
| Application | Online; up to three jobs in a rolling 30-day window | Whether your résumé clearly meets the minimum qualifications |
| Recruiter calls | One or two short phone or video conversations | Fit for the role, target level, location and logistics |
| Google Hiring Assessment | Online questionnaire, for some candidates | Workstyle fit, before interviews begin |
| Technical screen | One or two live coding interviews over video, 45 to 60 minutes each | Whether you get the full loop |
| Interview loop | About four to six interviews, virtual or in person | The written feedback your packet is built from |
| Hiring committee | Packet review; you do not attend | Hire or no hire, and at what level |
| Team matching | Conversations with hiring managers | Which team you join |
| Offer | Call with your recruiter | Compensation and benefits |
Application, recruiter, assessment and timing details come from Google's own hiring pages. Screen, loop and committee details come from candidate and former-interviewer accounts and prep publishers, and they vary by team, level and country.
Stage 1: Application and recruiter calls
Google asks for a résumé tailored to each job that plainly shows you meet the minimum qualifications and backs claims with data: what you accomplished, how it was measured and what you did. Cover letters are optional. You can apply to three roles in a rolling 30-day window, so choose the ones that genuinely fit.
Next come one or two shorter recruiter conversations over phone or video, which Google says check key skills for the role, explain the team and cover preferences such as location. Candidates describe the first call as about 30 minutes. Use it to:
- Confirm your target level. The level shapes the loop, with more design and leadership signal expected as you go up.
- Learn the format. How many screens, virtual or in person, which languages are fine, and whether a domain-specific round applies.
- Ask for prep time if you need it. Scheduling the screen when you are ready beats rushing into it.
- Raise accommodations early. Google says its recruiting team can arrange support such as interview breaks or extended time.
Before interviews, some candidates are also asked to take the Google Hiring Assessment, which Google says measures workstyle skills, and some roles add a coding exercise. Both are completed on your own, under the conditions set in your invitation.
Stage 2: The technical screen
The screen is a live coding interview over video. Candidates commonly report 45 to 60 minutes with one medium-difficulty data structures and algorithms problem, sometimes followed by a twist or a second, shorter problem. You write code in a shared editor that does not run it: accounts describe either a plain Google Doc or Google's own interview platform with syntax highlighting, depending on location and timing.
The number of screens is reported to vary by level. Candidates at L4 and below often get one, with a second only when the first is inconclusive, while L5 and L6 candidates commonly report two, a few days apart. Some recent L5 candidates report one of the two being a behavioral conversation instead, varying by recruiter and region.
The screen scores what the coding rounds score, at lower difficulty: clarifying the problem, reaching a working approach, writing correct code without a compiler and explaining your reasoning. Habits that help:
- Restate the problem and confirm inputs, constraints and one or two edge cases before writing anything.
- State the brute-force approach and its complexity, then improve it out loud.
- Write clean code with readable names; there is no compiler or autocomplete to catch slips.
- Trace a small test case by hand and give the final time and space complexity.
Stage 3: The interview loop, round by round
The loop, still often called the onsite, is a panel of interviews with different Googlers. Google says interviews happen over video or in person, and that it has reintroduced in-person interviews for some roles, often after initial rounds held virtually. Candidates commonly report four to six interviews of about 45 minutes each, usually with interviewers from across the company rather than the team you would join.
Coding (usually two or three rounds)
Harder than the screen and graded more strictly on code quality and edge cases. Reported topics include strings, sorting, graphs (including shortest paths and topological sort) and priority queues, among other classic data structures. Some rounds ask you to implement a small class with several methods, and interviewers often add a follow-up that changes a constraint. Our Google coding interview questions guide collects the commonly reported problem types.
System design (standard from L5 up)
An open-ended design discussion, typically 45 minutes. Prep publishers consistently describe dedicated design rounds from L5 up, and staff-level candidates report two or more, sometimes up to an hour each. For L4, accounts differ: one prep publisher says there is no dedicated design round, another says design concepts may come up inside coding rounds, and some candidates report a separate design round. Interviewers look for clarified requirements, a sensible architecture, trade-off reasoning about storage, caching, APIs and failure handling, and depth where they push.
Googleyness and Leadership
A behavioral round that mixes past-experience questions (“Tell me about a time…”) with hypotheticals. Google's prep page asks for specific examples rather than general statements and highlights how you handle ambiguity, work with teams and lead with or without a title. It is a scored round, not a formality, and prep guides for senior candidates describe it as a major input into your level. Prepare with our Googleyness and Leadership interview guide.
Role-related knowledge (some tracks)
For domain-focused roles such as Android or machine learning, candidates report that one coding round can be replaced by a role-related knowledge interview with an engineer from that domain. Google also pilots new formats: one prep publisher reports a code-comprehension interview being piloted in the second half of 2026 for some junior and mid-level roles on select US teams. If your recruiter describes a different format, prepare for that.
How the loop changes by level
The stages stay the same at every level, but the weight shifts from coding toward design and leadership as you go up. Titles are as listed on Levels.fyi; the emphasis is what candidates and prep publishers commonly report.
| Level | Title | Loop emphasis |
|---|---|---|
| L3 | SWE II (entry level) | Coding-heavy, with less weight on design and leadership |
| L4 | SWE III | Mostly coding plus Googleyness and Leadership; a separate design round is reported by some candidates, not all |
| L5 | Senior SWE | Coding plus at least one system design round; two screens common; leadership stories weigh more |
| L6 | Staff SWE | Strong coding assumed; two or more design rounds and multi-team leadership carry the most weight |
Your final level is decided after the loop, not at the recruiter call. Candidates report being offered one level below the one they interviewed for when the signal is mixed, for example when design or leadership answers land at the lower level's bar. Interviewing for L5 means preparing design and behavioral stories to the L5 bar, not just the coding.
How interviewers score you
Each interviewer writes structured feedback and a hiring recommendation. Google says everyone considered for a role is assessed against the same rubrics, and its re:Work guide to structured interviewing describes rubrics that define outstanding, solid, borderline and poor answers, naming role-related knowledge, problem solving and leadership among the attributes assessed. Former interviewers describe a scale from strong no hire to strong hire, submitted mostly asynchronously rather than debated in a meeting.
- The written feedback is the evidence. Reviewers read what was written, not what you meant. Say your assumptions, trade-offs and complexity out loud so they reach the notes.
- Process counts alongside the answer. Google's prep page says interviewers look at your thought process, not just the final answer, and that follow-up questions are normal.
- Consistency beats one great round. Former interviewers report that a packet of lukewarm “lean hire” scores can still end in a no. Prepare evenly across coding, design and behavioral.
Hiring committee, team matching and the offer
After the loop, Google says it brings together your application and interviews, applies various internal reviews, and may take several weeks to share an outcome. Candidate and former-interviewer accounts describe a hiring committee: a small group of engineers and managers who did not interview you. They read your résumé, recruiter and referral notes and every interviewer's feedback, then decide whether to hire you and at what level. You do not attend. If your résumé has changed, former interviewers suggest asking your recruiter to include the updated version.
Team matching is where you talk with hiring managers who have open headcount, and both sides have to opt in. Its order is one of the less consistent parts of the process:
- The long-standing order, still described by most of the guides we reviewed, is committee approval first and matching after.
- Some recent candidates report matching before the committee, so a manager who wants you can add support to your packet.
- One prep publisher notes that some European offices may reverse the two steps.
Treat matching as a real stage: be specific about what you want to work on, reply quickly, and ask each manager what the team ships and who you would work with. It is the most variable part of the timeline, and in rare cases candidates are approved without finding a team. Once a team and approvals are in place, your recruiter makes the offer and walks you through Google's compensation structure and benefits.
How to prepare, stage by stage
| Stage | What to prepare |
|---|---|
| Recruiter calls | A two-minute summary of your background and impact, your target level, location preferences and other processes |
| Technical screen | Timed medium problems written in a plain editor without running the code, explained out loud |
| Coding rounds | Harder problems plus follow-ups; practice extending a working solution when a constraint changes |
| System design | A repeatable 45-minute structure: requirements, API and data model, high-level design, one deep dive, trade-offs and failure modes |
| Googleyness and Leadership | Six to eight specific stories with measurable results, covering ambiguity, conflict, failure, feedback and leading without authority |
| Team matching | Two or three areas you want to work in, and questions for each manager |
The skill that carries across every stage is explaining your thinking while you work, and it only improves with spoken practice. A free AI mock interview in CoPilot Interview lets you paste the Google job description and your résumé, pick the level and a mix of coding, system design and behavioral questions, then answer aloud and get a score on each answer with what worked and what to improve. Use it before the screen and again before the loop; in the real interviews, Google's rule is no AI tools.
Rehearse your Google loop out loud
Paste a Google job description and your résumé into a free AI mock interview, choose your level and a mix of coding, system design and behavioral questions, and get a score on every answer with what worked and what to improve. The free plan gives you 15 minutes a day with no credit card.
Try a free AI mock interviewFAQ
How long does the Google software engineer interview process take?
Google says roughly six to eight weeks once interviews for a specific role begin. Team matching is the most variable step and can add weeks, so tell your recruiter early about any competing deadlines.
How many interviews are in the Google onsite for experienced engineers?
Candidates commonly report four to six interviews of about 45 minutes each, after one or two technical screens. The mix of coding, system design, Googleyness and Leadership, and role-related knowledge depends on your level and role.
Does Google still use a hiring committee?
Google's own pages describe the decision as various internal reviews rather than naming a committee, but candidate and former-interviewer accounts still describe a committee of engineers and managers who review your packet and set your level. You do not meet it.
Are Google interviews in person or virtual?
Both. Google says it has reintroduced in-person interviews for some roles, often after initial interviews held over video, and your recruiter confirms the format for your loop.
Can I use AI tools during a Google interview?
No. Google states that AI tools and Google Search are not permitted during interviews. Use them to prepare beforehand, then do the interviews on your own.
How soon can I reapply to Google after a rejection?
Google typically asks candidates to wait at least a year before reapplying for the same type of role, so they can gain more experience in the meantime.