Outline updated November 2026
Site Reliability Engineering
Class Duration
21 hours of live training delivered over 3 days.
Student Prerequisites
- Experience building or running services in production
- Comfort with the Linux command line
- Basic familiarity with containers and Kubernetes
- Some exposure to monitoring or logging tools is helpful
- No prior SRE experience required
Target Audience
Developers, operations engineers, and platform teams who run services in production and want fewer and shorter outages. It suits teams starting an SRE practice and teams moving from ticket-driven operations to SLOs. For instrumentation in depth, take Observability with OpenTelemetry. To add AI agents to incident response and runbooks, continue with AI for DevOps and SRE.
Description
This course teaches the practices site reliability engineering teams use to run services in production. Students define SLIs and SLOs, set error budgets, and write an error budget policy. They build burn-rate alerts, set up on-call, and manage incidents with clear roles. Later sections cover blameless postmortems, toil reduction, capacity planning, and safe releases. The course ends with reliability patterns, chaos engineering, and starting an SRE practice in an existing organization.
Learning Outcomes
- Explain SRE principles and how SRE relates to DevOps and platform engineering.
- Choose SLIs that reflect what users experience.
- Set SLOs and error budgets, and write an error budget policy.
- Alert on SLO burn rates instead of raw thresholds.
- Design an on-call rotation that people can sustain.
- Run incidents with an incident commander, clear roles, and regular updates.
- Write blameless postmortems and track follow-up actions.
- Measure toil and reduce it through automation.
- Plan capacity with load tests and demand forecasts.
- Release safely with canaries, feature flags, and automated rollback.
- Apply timeouts, retries, circuit breakers, and load shedding.
- Run chaos experiments to test how services handle failure.
- Report reliability with SLO reviews and DORA metrics.
Training Materials
Comprehensive courseware is distributed online at the start of class.
Software Requirements
Students will need a free, personal GitHub account to access the courseware, Docker Desktop or Podman, kubectl with a local Kubernetes cluster (kind or k3d), and a code editor (VS Code recommended). Prometheus, Grafana, and k6 run in containers. If students are unable to configure a local environment, a cloud-based environment can be provided.
Training Topics
SRE Principles
- What SRE is
- SRE, DevOps, and platform engineering
- Reliability as a feature
- Embracing risk
- SRE team models
Service Level Indicators
- What users experience
- Availability and latency SLIs
- Quality and freshness SLIs
- Request-based versus window-based SLIs
- Where to measure
SLOs and Error Budgets
- Choosing SLO targets
- Rolling and calendar windows
- Error budgets
- Error budget policies
- SLOs as code
- Reviewing SLOs with product owners
Alerting
- Symptoms versus causes
- Multi-window burn-rate alerts
- Reducing alert fatigue
- Pages versus tickets
- Dashboards for on-call
- Linking alerts to runbooks
On-Call
- Sustainable rotations
- Handoffs and escalation
- Runbooks and playbooks
- Measuring on-call load
- Follow-the-sun coverage
Incident Response
- Declaring an incident
- Severity levels
- The incident commander
- Incident roles
- Stakeholder updates
- Mitigation before root cause
- Incident tooling
Postmortems and Learning
- Blameless postmortems
- Timelines and contributing factors
- Moving past single root causes
- Tracking action items
- Sharing lessons across teams
Toil and Automation
- Defining toil
- Measuring toil
- The toil budget
- Choosing what to automate
- Automated remediation
Release Engineering
- Progressive delivery
- Canary releases
- Feature flags
- Automated rollback
- Error budgets and release decisions
Capacity and Performance
- Demand forecasting
- Load testing with k6
- Autoscaling
- Headroom and redundancy
- Cost versus reliability
Reliability Patterns
- Timeouts and retries with backoff
- Circuit breakers
- Load shedding and rate limiting
- Graceful degradation
- Health checks and probes
- Pod disruption budgets
- Multi-zone and multi-region designs
Chaos Engineering
- Steady-state hypotheses
- Fault injection
- Running game days
- Limiting the blast radius
- Chaos tools for Kubernetes
Building an SRE Practice
- Starting with one service
- Production readiness reviews
- Reliability reporting
- DORA metrics
- SRE roles and skills