All Roadmaps
Company Interview Prep
Google SRE Roadmap
Roadmap to crack Google SRE interviews. Covers system design, coding, Linux internals, networking, SRE principles, and Google-specific infrastructure knowledge.
6–12 months prep
7 phases
FoundationIntermediateAdvancedExpert
Phase 1
Data Structures & Algorithms
LeetCode medium-hard level required
Foundation8–12 weeks
What to learn
- Arrays, strings, hashmaps, linked lists
- Trees, graphs, BFS/DFS, topological sort
- Dynamic programming and greedy algorithms
- System design data structures — LRU cache, trie, bloom filters
- Time/space complexity analysis (Big O)
- Practice 150–200 LeetCode problems (medium focus)
Key tools
LeetCodeNeetCodePython / Go / C++
Phase 2
Linux & Systems Internals
Deep OS knowledge — Google tests this hard
Intermediate4–6 weeks
What to learn
- Linux boot process — BIOS/UEFI to userspace
- Process management — fork, exec, signals, zombies
- Memory management — virtual memory, page tables, swap
- File systems — inodes, ext4, VFS layer
- Networking stack — socket programming, TCP/IP internals
- Systemd, cgroups, namespaces (container foundations)
- Performance tuning — strace, perf, vmstat, iostat
Key tools
straceperftcpdumpeBPFsystemd
Phase 3
Networking Deep Dive
From L2 to L7 — Google's infra is network-heavy
Intermediate3–4 weeks
What to learn
- OSI and TCP/IP model — every layer matters
- DNS resolution in depth — recursive, authoritative, caching
- TCP — 3-way handshake, congestion control, window scaling
- HTTP/2, HTTP/3 (QUIC), and gRPC
- Load balancing — L4 vs L7, consistent hashing
- CDN architecture and anycast routing
- Network debugging — tcpdump, Wireshark, dig, traceroute
Key tools
tcpdumpWiresharkdigmtr
Phase 4
System Design
Design Google-scale distributed systems
Advanced6–8 weeks
What to learn
- Scalability — horizontal scaling, sharding, partitioning
- Consistency models — strong, eventual, causal
- CAP theorem and real-world tradeoffs
- Database selection — SQL vs NoSQL, when to use what
- Message queues — Pub/Sub, Kafka patterns
- Caching strategies — cache-aside, write-through, invalidation
- Design: URL shortener, rate limiter, chat system, search engine
- Design: monitoring system, distributed file system, CDN
Key tools
ExcalidrawSystem Design Primer
Phase 5
SRE Principles & Practices
The Google SRE book is your bible
Advanced3–4 weeks
What to learn
- SLIs, SLOs, SLAs — defining reliability targets
- Error budgets and error budget policies
- Toil reduction and automation philosophy
- Incident response — ICS, blameless postmortems
- Capacity planning and load testing
- Release engineering — canary, blue-green, progressive
- On-call best practices and escalation policies
Key tools
Google SRE Book (free)PrometheusPagerDuty
Phase 6
Google-Specific Knowledge
Understand Google's infrastructure philosophy
Expert2–3 weeks
What to learn
- Borg → Kubernetes evolution (container orchestration at Google)
- Colossus/GFS — distributed file systems
- Spanner — globally distributed database
- Zanzibar — global authorization system
- B4/Andromeda — Google's network infrastructure
- Monarch — monitoring at Google scale
- Read Google's published SRE case studies
Key tools
Google SRE BookGoogle CloudKubernetes
Phase 7
Interview Prep & Mock Interviews
Practice the exact interview format
Expert4–6 weeks
What to learn
- Coding rounds — 2-3 LeetCode medium/hard in 45 mins
- System design round — design for scale and reliability
- Troubleshooting round — debug a production outage live
- Linux/networking deep dive — explain kernel internals
- Behavioral (Googleyness) — collaboration, ambiguity
- Mock interviews — practice with peers or platforms
Key tools
Prampinterviewing.ioLeetCode
Interview Prep
DevOps Interview Prep Bundle — 1000+ Q&A
Every topic on this roadmap has interview questions in the bundle — Docker, Kubernetes, AWS, CI/CD, Linux, SRE, FinOps, System Design. Grab it before your next interview.
Frequently Asked Questions
Common questions about the Google SRE roadmap
1What is the Google SRE interview process?
Google SRE interviews include: coding (LeetCode medium-hard), system design (large-scale distributed systems), SRE-specific (troubleshooting, monitoring, incident response), Linux/networking fundamentals, and behavioral (Googleyness).
2How long should I prepare for Google SRE?
Most candidates prepare 4–6 months. This includes 2–3 months of LeetCode (200+ problems), 1–2 months of system design, and ongoing SRE concepts study. Consistency matters more than cramming.
3What programming languages does Google SRE use?
Google SREs primarily use Python, Go, and C++. For interviews, you can use any common language (Python is most popular). Production SRE work often involves Go for tooling and Python for automation.
4What is the Google SRE salary in 2026?
Google SRE L4 (entry): $180K–$220K TC, L5 (senior): $280K–$350K TC, L6 (staff): $400K–$500K+ TC. Total compensation includes base, bonus, and RSUs.
5Do I need a CS degree for Google SRE?
A CS degree helps but isn't required. Google values demonstrated skills — open-source contributions, relevant experience, and strong interview performance matter more. Many SREs come from sysadmin or DevOps backgrounds.