Google Site Reliability Engineer Interview Guide

The short answer: Google posts its SRE jobs as Software Engineer, Site Reliability Engineering (III, Senior and Staff) and as Staff or Senior Staff Site Reliability Engineer. Google publishes one hiring process for every role, and the most detailed description of the SRE loop is a 2015 article by Google SREs: a phone screen, then four or five one-on-one interviews, each on one topic such as programming, UNIX internals, networks or troubleshooting, with at least one coding interview and one non-abstract large system design (NALSD) interview. That description dates from 2015. Candidate reports from 2019 to 2025 describe a similar mix, and some software engineering track candidates report a loop much like the regular software engineer loop. Google says AI tools are not permitted during interviews. Last reviewed October 2026.

Google site reliability engineer interview: quick answers

The Google site reliability engineer role

What Google site reliability engineers work on, the skills its job postings ask for, and what a week can look like. Google posts the role as Software Engineer III, Senior Software Engineer and Staff Software Engineer, Site Reliability Engineering; Staff and Senior Staff Site Reliability Engineer; Site Reliability Engineer, SWE, Cloud.

Google site reliability engineer levels and pay

Your level sets the bar you are interviewed against and the pay band of the offer.

Google postings do not state L numbers. The ladder runs Software Engineer III (2 years of software development), Senior (5 years), Staff (8 years) and Senior Staff, and sre.google names Principal Engineer, Distinguished Engineer and Fellow above that. One candidate report labels Software Engineer III as L4.

Pay in Google's US job postings

Google's US SRE postings list a base salary range for the US as a whole. Each adds a bonus target (15% at III and Senior, 20% at Staff, 25% at Senior Staff) plus equity and benefits.

The location column is where the posting is based, since the range applies across the US. The Cloud SRE postings use a separate format with their own range. Ranges seen October 29, 2026.

Google site reliability engineer interview process

The steps follow Google's How we hire and interview tips pages and the SRE loop that Google SREs described in 2015. What each round covers today comes from candidate reports.

Based on Google's own pages and candidate reports.

Google says the process typically takes about 6 to 8 weeks once interviews start, that every candidate is scored on the same rubric with no brainteasers, and that applicants who are not selected should usually wait at least a year before reapplying for the same type of role. Candidate reports disagree on whether the software engineering track loop includes design and SRE interviewers, so ask your recruiter which rounds you will get. Last reviewed October 2026.

What is different at Google

• Google treats operations as a software problem. Its postings say SRE teams have full access and authority to fix, extend and scale the code they run, and the SRE book caps operational work (tickets, on-call, manual tasks) at 50 percent, with the overflow going back to the development team.
• There are two SRE tracks. The 2015 article names SRE-Software Engineer and SRE-Systems Engineer jobs, and the SRE book says about 50 to 60 percent of Google SREs were hired through the standard software engineer process and the rest were near that bar with extra skills such as UNIX internals and networking. All current US postings we found use Software Engineer style titles, and no Systems Engineer, SRE posting was live on October 28, 2026.
• The design round is NALSD. Google describes non-abstract large system design as design with concrete capacity math and trade-offs, and the 2015 article says naming a magic technology is not enough. Google SREs use the same method at work to plan resources and reason about scaling and failure domains.
• Topics follow your strengths. The 2015 article says each interviewer owns one topic, the mix is chosen around your self-assessed strengths, and interviewers try to find the limits of your knowledge.
• A hiring committee makes the decision. The 2015 article says the hiring committee reviews written feedback and team allocation happens after the hire decision, and the SWE bar inside SRE is the same as in product development so engineers can move between groups.
• AI tools are not allowed. Google's hiring pages say AI tools are not permitted during interviews, and current SRE postings say interviews are in person in most instances.

Google site reliability engineer interview questions

Questions from our bank, then practice prompts we wrote for this guide around Google's work.

1from typing import List, Tuple
2
3def slo_breaches(lines: List[str], p99_limit_ms: int, max_error_rate: float) -> Tuple[List[str], int]:
4    """Return (sorted hosts breaching the SLO, number of malformed lines)."""
5    pass

1import math
2from collections import defaultdict
3from typing import List, Tuple
4
5def slo_breaches(lines: List[str], p99_limit_ms: int, max_error_rate: float) -> Tuple[List[str], int]:
6    latencies = defaultdict(list)  # host -> latencies in ms
7    errors = defaultdict(int)      # host -> count of 5xx responses
8    malformed = 0
9    for line in lines:
10        parts = line.split()
11        if len(parts) != 4:
12            malformed += 1
13            continue
14        _, host, status, latency = parts
15        try:
16            status, latency = int(status), int(latency)
17        except ValueError:
18            malformed += 1
19            continue
20        if latency < 0 or not 100 <= status <= 599:
21            malformed += 1
22            continue
23        latencies[host].append(latency)
24        if status >= 500:
25            errors[host] += 1
26
27    breaching = []
28    for host, values in latencies.items():
29        values.sort()
30        p99 = values[math.ceil(0.99 * len(values)) - 1]  # nearest rank
31        if errors[host] / len(values) > max_error_rate or p99 > p99_limit_ms:
32            breaching.append(host)
33    return sorted(breaching), malformed
34
35# Complexity: O(n log n) time for the per-host sorts, O(n) space.

How to prepare

A plan for the Google loop, most important first:

1. Read the NALSD chapter of the SRE workbook and practice two design problems a week with real numbers for every component.
2. Practice troubleshooting out loud: take a symptom, list hypotheses, name the command for each and say what output would rule it out.
3. Review Linux internals and networking: processes and signals, file systems and links, and what happens when you type a URL.
4. Practice practical coding in your strongest language, such as log parsing and scripts that grow over several iterations, in a plain editor with no AI.
5. Build STAR stories about an outage, a postmortem, toil you removed and a disagreement, with impact stated as X, as measured by Y, by doing Z.
6. Ask your recruiter which SRE track you are on, which topics you can choose and whether your loop includes NALSD.

Practice path

Courses that cover the rounds above:

• Site Reliability Engineering Interview
• System Design
• Data Structures and Algorithms
• Python Basics