KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agents #developer-tools #typescript #codex #cli #claude-code #mcp #rust #deepseek-harness #ai-agent

google-sre-interview-handbook

★ 67 Open GitHub ↗

The definitive open-source playbook for Google Site Reliability Engineering (SRE) 2026+ interviews. Covers NALS, Linux Internals, and System Design.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# ⚡ The "Google SRE" Interview Handbook (2026+ Edition)

> **⭐ Finding this guide helpful?** 
> [Please click here to leave a Star on the official GitHub Repository](https://github.com/AceInterviews/google-sre-interview-handbook) so other engineers can find it!

---

> *"This is the definitive open-source study guide and playbook for the **Google SRE Interview** in 2026+ Interviews. If you are preparing for the **Non-Abstract Large System Design (NALSD)** round, **Linux internals troubleshooting**, or the **SRE coding interview**, these frameworks and diagnostic flowcharts will teach you how the Hiring Committee evaluates candidates."*

> **"The definitive open-source playbook for the modern Google Site Reliability Engineer (SRE). Moving beyond LeetCode to NALS, Linux Internals, and Reliability Architecture.An open-source map of how Google evaluates modern Site Reliability Engineers (SREs) — not a list of things to memorize."**

This repository documents the **mental models, evaluation rubrics, and failure patterns** behind modern Google SRE interviews.

It is not a question bank.  
It is not a LeetCode guide.  
It is not sufficient by itself.

It explains **how you are judged** — not whether you can execute under pressure.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)

> ### 🏆 Success Story (Jan 2026)
> *"I took your bundle... it helped me clear my practical coding/scripting round for an **L4 SRE role at Google**. It didn't just give me questions; it taught me how to **talk like an SRE**, using the right words like 'streaming' and 'iterators.' It was much more than Time and Space complexities."*
> 
> — **Ram M.**, (Cleared Google L4 Coding Round)
---
> > ### 📺 Watch the Breakdowns
> I regularly post deep-dives into these exact Google SRE interview patterns on YouTube.
>
> 👉 **[Click here to watch the full breakdown on YouTube](https://www.youtube.com/watch?v=HJHQIm_3zec)**
---

## 🚨 Why Most Strong Candidates Still Fail

Most Google SRE interview prep material is frozen in 2018:

* generic algorithms
* abstract system design
* surface-level DevOps checklists

The modern Google SRE loop evaluates something else entirely:

**Operational Maturity under incomplete information.**

Specifically:

1. **NALSD (Non-Abstract Large System Design)**
   Can you *diagnose and stabilize* a system you didn’t build — before redesigning it?

2. **Linux Internals & Kernel Reasoning**
   Can you debug resource contention without guessing or dashboard hopping?

3. **Reliability Architecture**
   Can you reason in error budgets, trade-offs, and blast radius — not features?

Many senior engineers fail not because they lack knowledge, but because they **sequence actions incorrectly under pressure**.

This repository exists to make that rubric visible.

---

## 🗺️ Learning Path: How to Navigate this Handbook

To get the most out of this resource, we recommend following the structured path below. These documents move from high-level mindset to deep technical execution.

### 🏁 Step 0: Onboarding & Roadmap
*   **[🚀 Getting Started](GETTING-STARTED.md)** - How to use this repository effectively.
*   **[🛤️ Learning Path](LEARNING-PATH.md)** - The recommended order of study for different seniority levels.
*   **[📅 Project Roadmap](ROADMAP.md)** - Ongoing updates and the future of SRE (AIOps, FinOps, etc.).

### 🧠 Pillar 1: The SRE Mindset & Strategy
*   **[🕵️ Real Interview Patterns](REAL-INTERVIEW-PATTERNS_2.md)** - The meta-game: How interviewers use silence and twists to test you.
*   **[⏱️ Execution Sequencing](01-SRE-Mindset/execution-sequencing.md)** - The hidden pass/fail signal: Doing the right things in the right order.
*   **[❌ Failure Patterns](01-SRE-Mindset/failure-patterns.md)** - A catalog of recurring ways senior engineers disqualify themselves.
*   **[✅ Counter-Patterns](01-SRE-Mindset/counter-patterns.md)** - The behavioral habits that separate a "Hire" from a "No Hire."

### 🏗️ Pillar 2: NALSD & System Design
*   **[⚔️ SRE vs. SWE Design](sre-vs-swe-design.md)** -  A side-by-side comparison of functional vs. hardened architecture.
*   **[🎧 Mock Interview Transcript](mock-interview-transcript.md)** - A fly-on-the-wall look at a live NALS round with grader notes.
*   **[📉 The NALS Playbook](02-NALSD-System-Design/google-nalsd-non-abstract-large-system-design-guide.md)** - The 8-step framework for diagnosing and scaling existing global systems.
*   **[🧮 NALSD Math Traps](02-NALSD-System-Design/nalsd-math-traps.md)** - The hidden physics: Bandwidth, IOPS, and Latency feasibility checks.

### 🐧 Pillar 3: Linux Internals & Troubleshooting
*   **[📜 Tactical Linux Cheat Sheet](03-Linux-Troubleshooting/google-sre-linux-troubleshooting-commands.md)** - The 20 commands that solve 80% of production incidents.
*   **[🔥 Incident Playbook: Kernel Panics](03-Linux-Troubleshooting/incident-playbook-kernel-panic.md)** - How to debug a frozen node you can't SSH into.
*   **[🌐 Incident Playbook: BGP Leaks](03-Linux-Troubleshooting/incident-playbook-bgp-leak.md)** - Troubleshooting when the Internet thinks you don't exist.
*   **[💾 Incident Playbook: Disk Pressure](03-Linux-Troubleshooting/incident-playbook-disk-pressure.md)** - Throughput vs. IOPS: The silent latency killer.
*   **[🔒 Incident Playbook: TLS Expiry](03-Linux-Troubleshooting/incident-playbook-tls-expiry.md)** - Handling global outages caused by certificate chain failures.

### 🐍 Pillar 4: Coding & Automation
*   **[🛠️ Coding Patterns for SREs](04-Coding-Automation/coding-patterns.md)** - Production-safe patterns for concurrency, retries, and streaming.
*   **[🐍 Python: Safe Log Streamer](04-Coding-Automation/safe_log_streamer.py)** - O(1) Memory pattern for TB-scale logs.
*   **[🐹 Go: Token Bucket Limiter](04-Coding-Automation/concurrent_health_checker.go)** - Real-world concurrency and rate-limiting logic.

### 💼 Pillar 5: Behavioral & Negotiation
*   **[🧾 Interviewer Scorecards](interviewer-scorecards.md)** - The 5 internal dimensions Google uses to assess seniority.
*   **[💬 The SRE-STAR(M) Method](05-Behavioral-Negotiation/google-sre-behavioral-interview-questions-star-method.md)** - How to pivot from "heroism" to "systemic prevention."
*   **[💰 Negotiation Pocket Card](05-Behavioral-Negotiation/negotiation-tips.md)** - Exact scripts to handle the "Expected Salary" trap.

### 🌙 The Final Prep
*   **[⭐ Night-Before-Onsite Checklist](Cheat_Sheet-Night_Before_Onsite.md)** - It is 12 hours before your Google SRE loop. Close all your other tabs. Go through this 5-step pre-flight checklist in order.

---

## 🧠 The Google SRE Mastery Pyramid (What Seniority Actually Means)

Passing senior/staff loops requires moving beyond *tool usage* into *systems reasoning*.

| Layer         | What’s Evaluated                    | What Most Candidates Miss     |
| ------------- | ----------------------------------- | ----------------------------- |
| Culture       | Blamelessness, RCAs, error budgets  | Treating outages as bugs      |
| Incident Eng  | Mitigate → Localize → Fix → Prevent | Root-cause obsession          |
| Observability | Kernel signals > dashboards         | Metrics as lagging indicators |
| Linux         | Resource contention reasoning       | Command guessing              |
| Kernel        | Scheduling, memory, networking      | “CPU is fine” fallacy         |

This pyramid is descriptive — not aspirational.

---

## 📘 Interview-Grade Linux Command Playbook (Excerpt)

> This is not a Linux cheatsheet.
> This is how Google evaluates *judgment* through command choice.

Most candidates know `tail`, `ps`, `lsof`.

Very few can explain **why that command, at that moment, under uncertainty**.

That difference is scored and decides interviews.

## 🎯 Why This Module Exists

In Google SRE interviews:

* You are **not evaluated on command memorization**
* You *are* evaluated on:

* prioritization
  * signal selection
  * reasoning under uncertainty
  * calm narration of thought process

Interviewers listen closely to:

> *“Why did you choose that command?”*

This playbook teaches **command → intent → signal** mapping.

## 🧠 The Mental Model Interviewers Expect

Before touching the keyboard, strong SREs silently ask:

1. Is this a **live system or historical issue**?
2. Am I looking for **symptoms or root cause**?
3. Is the problem **CPU, memory, I/O, network, or application-level**?
4. What is the **lowest-cost, highest-signal command** to start with?

This module trains that reflex.

## 🔥 Section 1 — Log Inspection (The First 5 Minutes Matter)

### `tail -f` — Live Signal, Not Noise

**When to use**

* Incident is ongoing
* You want to correlate behavior with time

**Interview narration**

> “I’ll start with `tail -f` to observe real-time behavior before making assumptions.”

**Example**

```bash
tail -f /var/log/nginx/error.log
```

**Signal interviewers look for**

* You didn’t start grepping blindly
* You value *temporal correlation*

### `tail -n` — Context Before Panic

**When to use**

* Incident already occurred
* You want *recent history*, not the full log

```bash
tail -n 200 /var/log/app.log
```

**What this shows**

* You understand **blast radius**
* You don’t overload yourself with data

### `grep` + `tail` — Precision Over Volume

Bad candidates:

```bash
grep error /var/log/app.log
```

Strong candidates:

```bash
tail -n 5000 /var/log/app.log | grep -i timeout
```

**Why this matters**

* Shows scoped thinking
* Shows intent to reduce false positives

## ⚙️ Section 2 — Process & Resource Awareness

### `ps aux` — Snapshot Thinking

**When to use**

* Need a fast view of resource-heavy processes

```bash
ps aux --sort=-%cpu | head
```

**Interview signal**

* You understand *static snapshots vs dynamic metrics*

### `top` vs `htop` — Conscious Tool Choice

**Good explanation**

> “I’ll use `top` first for a quick system-wide view before drilling deeper.”

Interviewers care **why**, not **which**.

## 🧵 Section 3 — File Descriptors & Hidden Killers

### `lsof` — The Silent Outage Detector

**Use cases**

* Port binding failures
* File descriptor exhaustion
* Stuck deleted files consuming disk

```bash
lsof -i :8080
```

**Narration**

> “This helps confirm whether the service is actually listening or blocked by another process.”

## 💾 Section 4 — Disk & I/O (Where Seniors Stand Out)

### `df -h` vs `du -sh`

Strong candidates **never confuse these**.

```bash
df -h
du -sh /var/*
```

**Key insight**

* `df` = filesystem view
* `du` = directory view

Interviewers *love* this distinction.

## 🧠 Section 5 — Memory & Kernel Signals

### `free -m`

```bash
free -m
```

**Strong explanation**

> “I’m checking memory pressure and reclaim behavior before assuming a leak.”

Bonus points if candidate mentions:

* page cache
* swap behavior

## 🌐 Section 6 — Network Sanity Checks

### `netstat` / `ss`

```bash
ss -lntp
```

**Use when**

* Service unreachable
* Connection exhaustion suspected

**Narration**

> “This confirms whether the service is bound and accepting connections.”

## 🔁 Section 7 — Putting It Together (Interview Scenario)

**Question**

> “The site is slow. CPU is normal. What do you do?”

**Strong answer flow**

1. `tail -n` logs for recent anomalies
2. `ss` to check connection backlog
3. `iostat` / disk wait (if available)
4. Only then form hypotheses

This shows:
✔ restraint
✔ prioritization
✔ system thinking

## 🚫 Common Interview Red Flags

Interviewers immediately notice when candidates:

* start grepping entire logs
* run commands without explaining intent
* jump tools without hypothesis
* over-optimize too early

This module trains you *out* of those habits.

## ⭐ Why This Section Improves Coding & Scripting Rounds

Even in **coding interviews**, Google evaluates:

* how you reason about input size
* streaming vs batch thinking
* observability mindset

Candidates who think like SREs:

* choose iterators
* avoid loading everything into memory
* explain tradeoffs clearly

This command mindset **directly transfers** to code.

## 🎯 Final Takeaway

Google doesn’t hire people who know Linux commands.

Google hires people who:

* know **which signal matters first**
* stay calm under ambiguity
* explain their thinking clearly
* choose tools intentionally

This playbook teaches exactly that.

---
> ## 🚫 What is NOT inside this free repository
> 
> This repo contains roughly 15% of the overall framework. It gives you the theory. It does not give you the simulation.
> 
> **The Premium Bundle (The Complete SRE Career Launchpad) additionally includes:**
> *   **✓ 20+ Deep-Dive Production Incidents** (Complete with Interviewer Prompts, Mitigation paths, and Hidden Scorecards).
> *   **✓ 70+ Production-Grade Coding Drills** (Python & Go patterns focusing on concurrency, safety, and streaming).
> *   **✓ The Offer Maximizer** (Word-for-word negotiation scripts for L4/L5/L6 bands).
> *   **✓ The First 90 Days Survival Guide** (How to build trust and automate toil instantly).

---

## 🚫 Where This Repository Intentionally Stops

This repository does **not** teach:

* executing these frameworks under interruption
* recovering after choosing the wrong first step
* handling mid-interview constraint reversals
* narrating trade-offs while being challenged

Those are **execution skills**, not reading skills.

This distinction matters.

Many candidates understand everything here — and still fail.

> ⚠️ Note: This repository provides foundational frameworks and mental models.
> Execution-level practice and full interview
> simulations live in the complete Google SRE preparation system.

---

## 🚀 If You Want to Train Execution (Not Just Understanding)

I built a **simulation-based preparation system** specifically to train:

* sequencing under pressure
* partial-information debugging
* interviewer-style interruptions
* recovery after wrong decisions

It exists because reading frameworks does not build reflexes.

If you want the **complete end-to-end preparation system**—including practice workbooks, mock simulations, and deep-dive scenarios—check out the full bundle:

👉 **The Complete Google SRE Career Launchpad**
[https://aceinterviews.gumroad.com/l/Google_SRE_Interviews_Your_Secret_Bundle_to_Conquer](https://aceinterviews.gumroad.com/l/Google_SRE_Interviews_Your_Secret_Bundle_to_Conquer)

**What's included in the full system:**
*   📘 **20+ Production Scenarios:** Deep dives into Kernel Panics, BGP Leaks, and connection storms, complete with interviewer scoring prompts.
*   🐍 **Coding Workbooks (Python & Go):** 70+ practice problems focusing on concurrency, automation, and safety—scored exactly how Google scores them.
*   💼 **The Offer Maximizer:** Word-for-word negotiation scripts that reflect real compensation committee logic to increase your final offer.
*   📅 **The 30-Day Prep Schedule:** A structured, day-by-day roadmap to interview readiness.

Use it or don’t — but understand the difference.

---

## 🤝 Contributing
Contributions are welcome! Please open an issue or PR if you have additional commands, patterns, or interview insights to share.

## 📄 License
MIT License. Free to use and share.

google-sre-interview-handbook

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README