kernelry
Specialty Role

Site Reliability Engineer (SRE) Competency Guide

Establish measurable service health, safe incident systems, and engineering leverage without on-call heroics.

SRE is a specialty path for engineers who can already operate a service independently and work safely in delivery. SREs partner with service, product, platform, security, and operations owners to define reliability contracts, improve alerting and incident systems, test capacity and resilience in a sandbox, and reduce measured toil through reviewed automation. Completion means you can defend an SLI and SLO, alert contract, incident record, experiment plan, and automation safety case. It does not require owning every host, cloud control, or platform product.

Key Focus Areas

Service Health and SLO Policy

User journeys, measurable SLIs and SLOs, alert contracts, and evidence-led diagnosis.

~45 Questions in Bank

Incident Systems and Learning

Role clarity, authorized mitigation, communication cadence, timelines, handoffs, and learning reviews.

~30 Questions in Bank

Resilience, Capacity, and Toil

Safe experiments, dependency protection, graceful degradation, and reviewed automation.

~35 Questions in Bank

What teams expect at this level

  • •Deep understanding of SLIs, SLOs, SLAs, and Error Budgets
  • •Strong Linux troubleshooting and performance analysis skills
  • •Ability to design resilient systems that degrade gracefully
  • •Experience with observability tools (Prometheus, Datadog, etc.)
  • •A methodical, calm approach to debugging production outages

Common Mistakes to Avoid

  • •Focusing only on MTTR (Mean Time To Recovery) without addressing root causes
  • •Alerting on symptoms rather than user-facing impact
  • •Treating SRE simply as "rebranded sysadmin" rather than software engineering
  • •Failing to consider capacity planning and load testing

How to Prepare

  • 1Read (or re-read) the Google SRE Book, especially the chapters on SLOs and Monitoring
  • 2Practice debugging scenarios: explain your methodology step-by-step
  • 3Understand the differences between RED (Rate, Errors, Duration) and USE (Utilization, Saturation, Errors) metrics
  • 4Review concepts like circuit breakers, retries with backoff, and bulkheads
Viewing milestone 01 of 09: Service Modeling and Reliability Contracts
Academy curriculum map

Site Reliability Engineering Reliability Practice Path

A nine-stage path for engineers who already diagnose services independently and participate safely in delivery. By completion, learners can define a user-journey SLO, make evidence-based reliability decisions, coordinate a controlled response, test resilience in a sandbox, and reduce measured toil through reviewed automation.

Learning lens:

Pipeline Progression • Click to Inspect:

Stage 01 / 09
01
Active Milestone Focus • Stage 01 of 09

Service Modeling and Reliability Contracts

SRE Philosophy
Learner outcome and safe practice progression:

Session 1 scenario: checkout succeeds in one region but intermittently stalls when inventory, payments, or an asynchronous order queue is slow. SRE begins with customer-visible behavior, not host graphs. Model the critical user journeys, request and dependency edges, data stores, queues, ownership boundaries, and graceful-degradation options. Mark which dependencies are synchronous, which can be stale, and which failures are safe to retry. Define a service contract with an owner, support hours, dependency assumptions, recovery objectives, and a small set of reliability risks. Practice progression: draw one request path, add failure domains and fallback behavior, then defend which dependency should receive the tightest objective and why. Measure progress by whether another engineer can name the blast radius and first safe mitigation from the model alone.

The Classic Interview Failure Trap:
Active Recall

“A team asks for CPU, memory, and uptime dashboards before it will document the service. What is missing from that request?”

Read-only evidence prompts for a supplied sandbox or authorized environment:
$rg -n 'checkout|payment|inventory|queue|timeout|owner' --glob '!node_modules/**' . | head -n 30
Locate service contracts, dependency names, timeout policies, and ownership evidence in a repository
Expected:A bounded sample of references to critical paths and dependencies. Empty or inconsistent results are evidence that the service model is tribal knowledge and needs an owner and source of truth.
$git log --all --format='%h %ad %an %s' --date=short --since='90 days ago' | head -n 20
Build a change-activity baseline before deciding which components are operationally risky
Expected:Recent change history with dates and authors. Treat it as a lead, then reconcile it with deployment ownership and runtime telemetry rather than assuming commit authors are service owners.
$python3 -c "edges=[('checkout','inventory','sync'),('checkout','payments','sync'),('checkout','orders','async')]; [print(f'{a} -> {b} [{mode}]') for a,b,mode in edges]"
Practice labeling synchronous and asynchronous dependency edges in a service model
Expected:Three explicit dependency edges. The exercise is complete when each edge has a timeout, retry policy, fallback, and owner written beside it in the learner's model.
Need deeper syntax breakdowns or step-by-step walkthroughs?Service model and ownership
Academy supporting lessons

Site Reliability Engineer (SRE) practice guides

Worked examples, safe practice boundaries, evidence interpretation, and role-specific reasoning prompts for every stage in this roadmap.

Related Guides

Interactive Scenario Drills

That's where we come in.

Practicing out loud transforms conceptual Site Reliability Engineer (SRE) knowledge into structured, confident explanations.

Kernelry helps you rehearse technical questions, evidence-led debugging, safe next steps, and the clear communication teams expect. The drills adapt to your answer, so you practice the reasoning rather than memorize a company-specific script. During early access, free accounts include ten daily scenarios across our mixed question pool, with no credit card required.