Platform SRE Engineer

Specialty · SR23

SR23: Platform / SRE Engineer — Building the Reliability Infrastructure

The Mission-Critical Role Reshaping How Tech Scales

Target audience: Senior DevOps engineers, senior developers wanting infrastructure depth, operations engineers ready to code
Timeline: 12–20 months (6–12 months core skills, 6–8 months on-the-job refinement)
ROI: Base salary +$35–55K over DevOps; equity upside in startups; career longevity to age 70+

1. SRE vs. Platform Engineering: The Distinction

Two related but distinct disciplines emerged in the 2020s. Understanding the difference is critical to your career choice.

Site Reliability Engineering (SRE)

Definition: The discipline of making systems reliable, measurable, and resilient under operational load.

Origin: Google's SRE book (2016) codified practices developed internally. Google published: reliability engineering as a discipline, not just operations.

Core philosophy:

  • Systems should fail gracefully; failures are inevitable
  • Measure reliability via Service Level Objectives (SLOs), not uptime percentages
  • Risk management via error budgets: if your SLO is 99.9%, you have a 0.1% error budget; burn it wisely
  • On-call rotations, incident response, post-mortems (blameless analysis)
  • Automation to prevent manual toil; "toil" is non-recurring, manual work

Key responsibilities:

  • Define SLOs, SLIs (Service Level Indicators), SLAs (Service Level Agreements)
  • Monitor systems; detect and resolve incidents
  • Conduct post-mortems after outages (find root causes, prevent recurrence)
  • Build automation to reduce toil
  • Capacity planning (predict when you'll run out of resources)

Example day: Incident response drill. A microservice crashes. SRE detects via monitoring (latency spike, error rate spike). Alerts fire. SRE pages on-call engineer. 5 minutes to root cause (bad deployment). Rollback. System recovers. SRE schedules post-mortem. Next week: "Why didn't CI/CD catch this? Let's add a smoke test."

Salary range: Entry $105K → Senior $160K → Staff $200K+ (USD).

Platform Engineering / Internal Developer Platform (IDP)

Definition: Building tools, services, and workflows to maximize developer velocity and reduce cognitive load.

Origin: Gartner coined "Platform Engineering" in 2023. Emerged as a response to DevOps fatigue: every dev team was rebuilding deployment pipelines, monitoring, security gates, etc.

Core philosophy:

  • Developers are customers; their experience matters
  • Abstract complexity (CI/CD, security, compliance, observability) behind self-service APIs
  • Golden Path: a opinionated, well-trodden route to deploying code
  • Internal Developer Platform (IDP): unified tooling (version control, deployment, monitoring, cost tracking)
  • Kubernetes as the abstraction layer, not the product

Key responsibilities:

  • Build self-service deployment templates (Backstage, Crossplane, or custom)
  • Design CI/CD golden paths (e.g., "commit code → automated tests → staging deploy → production")
  • Standardize observability (Prometheus, Grafana, OpenTelemetry)
  • Manage secrets, RBAC, audit logging
  • Support developers (onboarding, troubleshooting, API documentation)
  • Enforce compliance & security policies (shift-left: catch issues early)

Example day: A backend team wants to deploy a new microservice. They fill out a form in your platform (service name, language, region, scale). Your platform:

  1. Creates Git repo with scaffold code + tests
  2. Configures CI/CD pipeline
  3. Deploys to staging automatically
  4. Sets up monitoring (logs, metrics, traces)
  5. Creates runbook for common issues
  6. Notifies the team: "Your service is live at service.company.internal."

Time to production: Reduced from 2 weeks (manual setup) to 2 hours (platform-driven).

Salary range: Entry $105K → Senior $160K → Staff $200K+ (USD).

The Overlap (and the Confusion)

Both roles:

  • Use Kubernetes, Terraform, cloud platforms
  • Care about reliability, cost, automation
  • Own on-call rotations (often)
  • Build monitoring, incident response

Key difference:

  • SRE: Focused on operations. How do we keep systems running? How do we respond to failures?
  • Platform: Focused on developer experience. How do we make it easy for developers to deploy, monitor, and operate their systems?

In practice: Many companies blur the line. A Platform team will include SRE principles (monitoring, alerts, incident response). An SRE team will build tools to improve developer velocity.

Career impact:

  • SRE is more established, with clearer career progression at big tech (Google, Meta, Amazon)
  • Platform Engineering is newer, hotter, with startups and enterprises hiring heavily
  • Both are in-demand; both command high salaries

2. Who Becomes a Platform / SRE Engineer?

Senior DevOps Engineers Pivoting to Platform / SRE

Your advantage: You've managed CI/CD, infrastructure, provisioning. You understand cloud primitives.

Your gap: You may lack SRE discipline (SLOs, error budgets, incident response rigor). You may not have shipped at massive scale (millions of requests/sec).

Typical path: 9–14 months with deliberate upskilling.

Senior Software Engineers Pivoting to Infrastructure

Your advantage: You write production code; you understand systems design, testing, architecture decisions.

Your gap: You likely haven't managed infrastructure at scale. Kubernetes, distributed systems, observability may be new.

Typical path: 12–18 months; deeper learning curve but faster architectural thinking.

Operations Engineers Ready to Code

Your advantage: You understand incident response, on-call culture, production debugging.

Your gap: Your coding skills may be script-level (bash, Python for automation). Production engineering (APIs, service design, reliability patterns) is different.

Typical path: 12–18 months; invest heavily in systems design and coding.

3. Core Skill Set: The Non-Negotiable Foundation

Kubernetes (K8s) — The Mandatory Skill

Why: Kubernetes market adoption reached 73% of enterprises in 2024. Every cloud-native org runs Kubernetes. SRE/Platform engineers must be Kubernetes experts.

Core concepts you must own:

  • Pods (smallest unit of deployment)
  • Deployments, ReplicaSets, StatefulSets, DaemonSets (workload controllers)
  • Services, Ingress (networking)
  • ConfigMaps, Secrets (configuration)
  • PersistentVolumes, PersistentVolumeClaims (storage)
  • Namespaces, RBAC (multi-tenancy, access control)
  • Resource requests, limits, QoS (scheduling)
  • Probes (liveness, readiness, startup)
  • Custom Resource Definitions (CRDs) — extend Kubernetes API

Hands-on mastery:

  • Deploy a multi-tier application (frontend, backend, database)
  • Scale deployments; understand rolling updates, blue-green deployments
  • Debug a pod crash (logs, events, describe)
  • Upgrade Kubernetes cluster without downtime
  • Set resource limits; understand pod eviction

Resources:

SRE Discipline & Reliability Thinking

Service Level Objectives (SLOs)

  • SLI (Service Level Indicator): A measurable metric (e.g., "99% of requests complete in <100ms")
  • SLO (Service Level Objective): A target (e.g., "99.9% availability")
  • SLA (Service Level Agreement): A contract with external penalties (e.g., "99.95% uptime or customers get a credit")

How to set SLOs:

  1. Identify what matters to users (latency, availability, throughput)
  2. Measure current performance (baseline)
  3. Set ambitious but achievable targets (e.g., 99.9% vs. 99.99%)
  4. Monitor religiously; alert if SLO is at risk

Error budgets: If your SLO is 99.9% (three nines), your error budget is 43.2 minutes/month. You can spend this on:

  • Deployments (inevitable brief downtime)
  • Experiments (blue-green tests)
  • Cost optimization (use cheaper, less reliable hardware)

The key insight: Don't aim for 99.99% if 99.9% is sufficient. Extra nines are expensive (more redundancy, faster failover, more testing).

Resources:

Incident Response & Post-Mortems

  • On-call rotations: responsibility to respond quickly to alerts
  • Incident commander role: lead response during outages
  • Blameless post-mortems: analyze what happened, not who failed
  • Runbooks: step-by-step guides for common incidents

Resources:

Infrastructure as Code (IaC)

Terraform (dominant, cloud-agnostic)

  • Define AWS, GCP, Azure resources in HCL (HashiCorp Configuration Language)
  • State management (track deployed resources)
  • Plan before apply (preview changes)
  • Modules (reusable infrastructure components)

Learning path:

  • HashiCorp Learn Terraform
  • Hands-on: Define VPC, security groups, EC2 instances, RDS database in Terraform
  • Advanced: Write modules, manage state remotely (S3 backend), handle secrets

Alternative IaC tools:

  • AWS CloudFormation (AWS-specific, JSON/YAML)
  • Pulumi (code-as-IaC: Python, Go, TypeScript; more flexibility than Terraform)
  • Crossplane (Kubernetes-native IaC)

Resources:

Observability: Monitoring, Logging, Tracing

Prometheus (metrics collection)

  • Time-series database (store "CPU at 45% at 3:04 PM")
  • Scrape metrics from applications (via exporters)
  • Alerting rules (trigger alerts when metrics exceed thresholds)

Grafana (visualization)

  • Dashboard creation (visualize Prometheus metrics)
  • Alerting (alternative to Prometheus alertmanager)

OpenTelemetry (distributed tracing)

  • Instrument applications to emit traces (understand request flow across microservices)
  • Exporters: send traces to Jaeger, Datadog, etc.

Logging (centralized log aggregation)

  • Elasticsearch (log storage)
  • Fluentd or Logstash (log shipping)
  • Kibana (visualization)
  • Modern alternative: Datadog Logs, New Relic, Honeycomb

Datadog (all-in-one observability)

Resources:

Cloud Platforms (Deep Expertise in One)

AWS

  • EC2 (virtual machines)
  • VPC (networking)
  • RDS (managed databases)
  • S3 (object storage)
  • Lambda (serverless functions)
  • ECS/EKS (container orchestration)

Google Cloud

  • Compute Engine (EC2 equivalent)
  • Cloud SQL (managed databases)
  • Cloud Storage (S3 equivalent)
  • Cloud Functions (Lambda equivalent)
  • GKE (managed Kubernetes; more mature than EKS)

Azure

  • VMs (EC2 equivalent)
  • App Service (managed app hosting)
  • AKS (managed Kubernetes)
  • Azure DevOps (integrated CI/CD)

Strategy: Master one cloud deeply. Learn the others conversationally. Choose based on employer: AWS is dominant in startups/FAANG, Azure in enterprises, GCP in ML/data teams.

GitOps & Continuous Deployment

ArgoCD (Kubernetes-native GitOps)

  • Declare desired state in Git repos
  • ArgoCD syncs Kubernetes cluster to match Git
  • Pull-based: cluster pulls changes from Git (safer than push-based CI/CD)

Flux (alternative GitOps tool)

  • Similar to ArgoCD; more modular

Why GitOps:

  • Git is your source of truth (audit trail, rollback)
  • Separation of concerns (Git admins != Kubernetes admins)
  • Drift detection (if someone manually changed prod, ArgoCD alerts)

Resources:

Chaos Engineering

Concept: Deliberately inject failures into production (in a controlled way) to test resilience.

Tools:

Examples:

  • Kill a random pod; does the app recover?
  • Introduce latency on network calls; does the system timeout gracefully?
  • Fill disk to 90%; does alerting trigger?

Resources:

4. Certification Strategy & Timeline

Tier 1: Kubernetes Certifications (Mandatory for Platform/SRE)

CKA — Certified Kubernetes Administrator

CKAD — Certified Kubernetes Application Developer

  • Cost: USD 395 (includes 1 free retake)
  • Prep time: 6–8 weeks (easier than CKA; app dev focus, not cluster admin)
  • Why: Optional but useful. Complements CKA (shows you can build on K8s, not just operate it).

CKS — Certified Kubernetes Security Specialist

  • Cost: USD 395
  • Prep time: 8–12 weeks (requires CKA knowledge + security depth)
  • Why: Optional; valuable if your org has security-first culture.

Tier 2: Cloud Platform Certifications

AWS

Google Cloud

Azure

Tier 3: IaC & Tooling

HashiCorp Certified: Terraform Associate (TA-003)

  • Cost: USD 70.50
  • Prep time: 4–6 weeks
  • Why: Quick win; proves IaC competence.
  • Study resources: HashiCorp Learn

Datadog Certified Associate

  • Cost: USD 250
  • Prep time: 6–8 weeks
  • Why: If your org uses Datadog, this is valuable.

Recommended Timeline (18–24 months)

PhaseMonthCertCostEffortNotes
Phase 11–12CKA$395120 hrsMandatory; highest ROI
Phase 16–10Terraform Associate$70.5050 hrsParallel with CKA
Phase 213–20AWS DevOps Engineer Pro (DOP-C02)$300100 hrsOr GCP DevOps Eng
Phase 218–24CKAD or CKS$39580 hrsOptional deepening

Your path: CKA first (mandatory). Terraform Associate next (quick). Then one cloud cert based on employer. Skip CKAD unless you want app-dev skills.

5. Career Progression & Salary

Career Ladder

  1. Junior Platform / SRE Engineer (0–2 years)

    • Shadows senior engineers
    • Responds to alerts under guidance
    • Builds small automation (scripts, Terraform)
    • Salary: USD 105–140K

  2. Platform / SRE Engineer (2–5 years)

    • Owns on-call rotation
    • Incident commander
    • Designs features for IDP
    • Leads deployment automation
    • Salary: USD 140–180K

  3. Senior Platform / SRE Engineer (5–10 years)

    • Owns reliability for critical systems
    • Mentors junior SREs
    • Sets SLO strategy
    • Leads architecture decisions (Kubernetes upgrade, observability stack, etc.)
    • Salary: USD 160–230K

  4. Staff Platform / SRE Engineer (10+ years)

    • Org-wide reliability strategy
    • Recognized expert in domain (Kubernetes, observability, chaos engineering)
    • Leads multi-team initiatives
    • Salary: USD 200–300K+

  5. Director of Platform / VP of Engineering Infrastructure

    • Sets company-wide technology strategy
    • Manages teams of platform/SRE engineers
    • Responsible for cost, reliability, security across all systems
    • Salary: USD 250–400K+ (plus equity, bonus)

Global Salary Table (USD, ZAR, GBP, EUR, AUD)

RoleUSDZAR (×18)GBPEURAUD
Junior Platform/SRE$105KR1.89M£82K€93K$160K
Platform/SRE Engineer$155KR2.79M£120K€135K$235K
Senior Platform/SRE$200KR3.6M£155K€175K$305K
Staff Platform/SRE$240KR4.32M£185K€210K$365K
Director of Platform$300KR5.4M£230K€260K$455K

Sources: Levels.fyi, PayScale, Glassdoor, LinkedIn Salary

6. South Africa Context: SRE / Platform Hiring & Salaries

SA Companies Hiring SRE / Platform Engineers (2026)

Banking & Financial

  • Capitec Bank: Infrastructure modernization; Kubernetes adoption accelerating
  • Nedbank: Cloud migration (AWS); SRE team of 30+
  • ABSA: Platform team for internal developer tooling
  • FirstRand / FNB: DevOps → SRE transition; reliability focus

Tech & Startups

  • Takealot: Platform team (15+ engineers); Golden Path initiative
  • Yoco: Small but growing platform team
  • Jumo: Reliability engineering for fintech

Consulting & Professional Services

  • Deloitte SA: Cloud infrastructure practice
  • PwC SA: Cloud ops center
  • EY SA: Infrastructure managed services

SA Salary Ranges (ZAR, as of 2026)

RoleZARNotes
Junior Platform/SRER1.6M–2MEntry-level; CKA + 1y experience
Platform/SRE EngineerR2.3M–3MMid-level; 3–5 years experience
Senior Platform/SRER3M–4MLeadership; architect-level decisions
Director/VPR4M–6MRare; organization-wide responsibility

Remote opportunity: Many SA engineers work remotely for US/EU companies and earn USD salaries. Major remote employers: Canonical, GitLab, Automattic, HashiCorp (remote-first policies). Earnings: 35–40% premium vs. local ZAR roles.

POPIA & compliance: South African employers increasingly value SREs with compliance expertise (POPIA, data residency, audit logging). Commands 10–15% premium.

7. Daily Life: SRE/Platform Engineer in Two Contexts

Day in the Life: Startup (Series B, 30–50 engineers)

8:00 AM: Start week with on-call handoff. Previous week's SRE experienced 2 incidents (both resolved; no customer impact). Your week starts clean.

9:00 AM: Standup with platform team (4 engineers, 1 tech lead). Review sprint progress. You mention: Golden Path template for Node.js services (90% done); need final code review.

10:00 AM: 1-on-1 with your tech lead. Discuss on-call feedback: "Last week I had to manually restart a pod. The app wasn't recovering from transient DB connection failures." Tech lead agrees: "Let's add readiness probes to detect that. Design doc by Friday?"

11:00 AM: Deep work. Write design doc: "Readiness Probe Strategy for Microservices." Content: What is a readiness probe? Current state (missing on 40% of services). Proposed: Mandate readiness probes in Golden Path template; audit existing services; alert if probe fails 3x in a row. Estimated effort: 40 hours (2 weeks). Sent to team Slack.

1:00 PM: Lunch. Casual chat with backend engineer: "I want to deploy a new service. What do I do?" Perfect opening to pitch your IDP work. "Fill out this form in Backstage; it'll generate a GitHub repo, CI/CD pipeline, and Kubernetes manifest. Deploy to staging immediately."

2:00 PM: Pair program with junior SRE. She's working on monitoring rule for a critical service. Together, you set SLO (99.5% latency < 200ms), define SLI (query Prometheus for p99 latency), set alert threshold (if SLI breaches SLO, alert). She learns the pattern; next time she'll do it solo.

3:30 PM: Incident! A service is in a crash loop. Junior SRE pages you (on-call). You SSH into cluster, check logs: "Out of memory." Check resource limits: 512MB (too low). Scale up, restart. Service recovers in 90 seconds. Post to #incidents Slack. Schedule post-mortem for tomorrow.

4:30 PM: Schedule post-mortem. Happened because the backend team underestimated memory. Your golden path should have a memory estimation guide. Add to backlog.

5:00 PM: Write up incident in incident tracking system (PagerDuty / custom). Notes: what happened, impact (service down 90 sec, 0.05% request loss), root cause (under-resourced), follow-up (add memory guide to golden path).

5:30 PM: Leave. On-call pager stays with you; hopefully quiet night.

Day in the Life: Enterprise Bank (SRE-heavy culture)

7:00 AM: Check email. Compliance reminder: POPIA breach notification SLA is 3 days; any incident? No current incidents. Good.

9:00 AM: SRE standup (20 engineers, multiple teams). Each team reports: incidents from previous week, current focus. Your team (Platform SRE): completed Kubernetes upgrade to 1.28, reduced deployment time from 30 min to 8 min. On-call metrics: 12 alerts (9 resolved automatically, 3 escalated). MTTD (mean time to detect): 45 sec. MTTR (mean time to resolve): 8 min. Good.

10:00 AM: Reliability review meeting. Product team pitches new feature (peer-to-peer payments). SRE questions: What's the SLO? Product: "99.95% availability." SRE: "That's 22 minutes of downtime/year. How will you achieve it?" Architect: "Multi-region, active-active." SRE: "Latency implications? Data consistency?" Discussion ensues. SRE signs off: "Proceed with design; we'll do formal review in 2 weeks."

11:30 AM: Write SRE perspective into the design doc. Include: SLO, error budget, monitoring plan, incident response playbook (what to do if payment service goes down?).

1:00 PM: Lunch with senior SRE. Discuss on-call rotation. She mentions: "I'm burnt out. Last month, 3 major incidents. Working nights." SRE lead takes this seriously. Next team meeting: "Let's review incident patterns. Are they preventable via better monitoring, chaos engineering, or code changes?"

2:00 PM: Design review: "Chaos Engineering Strategy." Your proposal: Monthly chaos injection (kill random pods, inject latency, fill disks). Measure: does the system recover? Do alerts fire? Does runbook help? Skeptics: "This sounds risky." You counter: "Better to find problems in controlled chaos than in production with customers impacted." Approved for 2-month pilot.

3:30 PM: 1-on-1 with junior SRE. She recently passed CKA. Discuss: "What's next?" Suggest: AWS DevOps Engineer cert (3 months), then lead Kubernetes upgrade project (6 months). Goal: senior SRE within 2 years.

4:30 PM: Update incident management system. Previous month: 24 alerts, 8 escalated, 0 customer-facing incidents (good). Mean MTTD: 40 sec. Mean MTTR: 12 min. Trends: improving. Share dashboard with leadership.

5:00 PM: Oncall check-in. Tonight's SRE: "Quiet so far; monitoring looks good." You're on-call next week. Review critical system runbooks (know-before-you-page material).

5:30 PM: Leave. Compliance training pending (POPIA, incident response procedures). Schedule for next week.

8. The On-Call Reality

What Is On-Call?

On-call rotation: Your team divides into groups. Each week (or every 2 weeks), your group "owns" production. You carry a pager. If something breaks:

  1. Alert fires (Datadog, PagerDuty, etc.)
  2. Pager goes off (phone call, SMS, app notification)
  3. You respond (check system, diagnose, fix or escalate)
  4. Document (log incident, schedule post-mortem)

On-Call Frequency

  • Startup: 1-week rotations (4 engineers → each on-call 1 week every 4 weeks)
  • Mid-size company: 2-week rotations (8 engineers → each on-call 1 week every 8 weeks)
  • Large company: 3–4 week rotations (more depth of on-call specialists)

The Truth About Pager Fatigue

Burnout from on-call is real. Constant alertness (even if quiet) causes:

  • Sleep disruption
  • Stress & anxiety
  • Difficulty focusing on deep work
  • Higher turnover

Healthy practices:

  • Limit pages per week (should average 1–2, not 20)
  • Compensatory time off (if you're paged at 2 AM, you leave early the next day)
  • Automated response (90% of alerts should auto-remediate)
  • Blameless post-mortems (psychology of learning, not blame)
  • Team support (backup on-call if you're overwhelmed)

Compensation:

  • On-call bonus (varies: $500–$2000/week depending on alert volume)
  • Or: Comp time (for every page, get 30 min–1 hr off next work day)

SLAs and On-Call SLOs

  • Response SLA: Must respond to page within 15 minutes
  • Resolution SLA: Must resolve critical incidents within 1 hour
  • Detection: Monitoring should alert within 5 minutes of incident start

9. Common Specializations in SRE / Platform

Kubernetes Specialist

  • Deep expertise in Kubernetes (cluster upgrades, networking, storage, security)
  • Tools: Helm, Kustomize, custom controllers
  • Salary premium: +10–15%

Observability / Monitoring Specialist

  • Design observability architecture (metrics, logs, traces)
  • Tools: Prometheus, Grafana, ELK, Datadog, OpenTelemetry
  • Salary premium: +10–15%

Reliability Engineer (SLO Architect)

  • Define SLOs, error budgets, reliability metrics
  • Tools: SLO monitoring, incident tracking
  • Salary premium: +15–20% (highly valuable; fewer experts)

Infrastructure Automation Specialist

  • Deep Terraform, Pulumi, CloudFormation expertise
  • Automate infrastructure provisioning, scaling, cost optimization
  • Salary premium: +10%

Chaos Engineering Specialist

  • Design chaos experiments, conduct game days
  • Tools: LitmusChaos, Gremlin, custom frameworks
  • Salary premium: +10–20% (newer field; specialized)

Internal Developer Platform (IDP) Specialist

  • Design self-service platforms (Backstage, Crossplane, custom)
  • Focus: developer experience, golden paths, secrets management
  • Salary premium: +10–15% (hot field)

10. 12–20 Month Upskilling Path

Months 1–4: Kubernetes Foundations (60 hours/month)

Goal: Comfortable deploying, scaling, debugging on Kubernetes.

Weekly schedule:

  • 15 hrs: Linux Foundation CKA course (or A Cloud Guru)
  • 12 hrs: Hands-on labs (minikube locally, K3s in cloud)
  • 10 hrs: Kubernetes documentation reading
  • 8 hrs: Build projects (deploy an app, troubleshoot)

Projects:

  • Deploy a multi-tier app (Nginx, Node.js, Postgres) on K3s
  • Configure storage, networking, RBAC
  • Write custom manifests (no Helm yet)

Cost: Course $300–500; lab platforms free–$35/mo.

Months 5–8: CKA Exam Prep & Cloud Basics (70 hours/month)

Goal: Pass CKA; understand cloud essentials.

Weekly schedule:

  • 18 hrs: CKA practice exams + weak area review (Killer.sh is critical)
  • 10 hrs: Cloud platform basics (AWS EC2/VPC or GCP Compute/VPC)
  • 10 hrs: IaC intro (Terraform basics)
  • 8 hrs: Observability intro (Prometheus, Grafana)

Deliverables:

  • Pass CKA exam (or schedule for month 10)
  • Deploy a Kubernetes cluster on a cloud platform
  • Write a Terraform module to provision a cluster

Cost: CKA exam $395; cloud credits free tier.

Months 9–12: SRE Discipline & Tool Mastery (70 hours/month)

Goal: Understand SRE practices; earn cloud cert or Terraform cert.

Weekly schedule:

  • 15 hrs: Google SRE book + practice (read, take notes, think about your systems)
  • 12 hrs: Observability depth (Prometheus, Grafana, alerting rules)
  • 12 hrs: Cloud platform cert prep (AWS DOP-C02 or GCP DevOps)
  • 8 hrs: Incident response drills, post-mortems

Deliverables:

  • Design a monitoring + alerting system for a service (write SLO, SLI, alert rules)
  • Read & summarize 2–3 Google SRE essays
  • Lead a blameless post-mortem (even if fictional)

Cost: Cloud cert $200–300; subscriptions ~$50/mo.

Months 13–18: Cloud Cert & Specialization (60 hours/month)

Goal: Earn cloud platform cert; deepen in chosen specialization.

Path A: AWS/Kubernetes Infrastructure

  • Prepare for AWS DevOps Engineer Professional (DOP-C02)
  • Projects: Terraform + Kubernetes on AWS (EKS), cost optimization, scaling

Path B: Observability / Monitoring

  • Deep Prometheus, Grafana, Datadog
  • Projects: Design SLO monitoring, set up alerting from scratch

Path C: Platform Engineering

  • Design Internal Developer Platform (IDP) on Kubernetes
  • Tools: Backstage, Crossplane, or ArgoCD
  • Projects: Self-service service deployment, golden path

Deliverables:

  • Pass cloud platform cert (or schedule for month 20)
  • Build end-to-end project (e.g., multi-region Kubernetes cluster on cloud with monitoring)

Cost: Cert ~$200–300; lab platforms ~$50–100/mo.

Months 19–24: Job Search & On-the-Job Learning (50 hours/month)

Goal: Land Platform/SRE role; deepen via on-the-job learning.

Pre-job:

  • Polish resume: highlight CKA, certifications, Kubernetes + cloud projects, SRE mindset
  • Target companies: Startups (need reliability), banks (risk-averse; SRE-heavy), tech giants (SRE is core)
  • Prepare: system design interview (how would you architect this service for 99.99% uptime?), incident simulation, troubleshooting

First 90 days in role:

  • On-call shadow: ride along with experienced SRE; learn incident response
  • Read prod systems: understand architecture, monitoring, SLOs
  • Incident response: participate in real incidents (don't lead yet)
  • Ops work: small automation tasks, runbook improvements
  • Mentorship: pair with senior SRE

Total investment: ~1,100–1,300 hours over 20 months. Realistic with full-time work (20 hrs/week).

11. Recommended Books, Courses & Resources

Books

  1. Site Reliability Engineering: How Google Runs Production Systems (2016) — Free HTML
    The foundational SRE text. Read Chapters 1–4, 6, 16.

  2. The Phoenix Project (2013) by Gene Kim, Kevin Behr, George Spafford
    ISBN 978-0988262935 — Novel form; teaches DevOps culture.

  3. Release It! (2nd ed., 2018) by Michael Nygard
    ISBN 978-1680502398 — Production patterns, failure scenarios, case studies.

  4. Building Microservices (2nd ed., 2021) by Sam Newman
    ISBN 978-1492034018 — Architecture for reliability.

  5. Kubernetes in Action (2nd ed., 2021) by Marko Lukša
    ISBN 978-1617297618 — Practical Kubernetes deep-dive.

Courses

  1. Linux Foundation Certified Kubernetes Administrator (CKA)
    Official training — $645 (bundled with exam)

  2. A Cloud Guru CKA Path
    Link — $35/mo, excellent

  3. Coursera SRE Fundamentals
    Link — Free to audit

  4. Linux Academy / A Cloud Guru Kubernetes & DevOps paths
    Multiple courses covering K8s, Terraform, cloud platforms

  5. Made With ML (Free)
    Link — MLOps + SRE intersection

Online Resources (Free)

Communities

12. The "Lawyer vs. Technologist" Tension in SRE

Unique to SRE: the tension between risk and speed.

The technologist says: "Deploy faster. Automation eliminates human error. Chaos engineering proves resilience. CD (continuous deployment) is safer than quarterly releases."

The risk/legal person says: "Change is risk. Approvals ensure compliance. Audit trails prove governance. Manual review prevents disasters."

Reality: Both are right. The best SRE orgs navigate this tension:

  • Blue-green deployments: Deploy to production, but don't route traffic yet. Smoke tests, validation. Then switch. Zero-downtime, easy rollback.
  • Canary releases: Route 1% of traffic to new version. Monitor for 30 min. If metrics good, gradually increase (10%, 25%, 100%). Catch issues early.
  • Approval gates + automation: Require approval for production changes, but the deployment itself is automated (no manual SSH into servers).
  • Blameless post-mortems: Learn from incidents without legal liability. Separate from audit/compliance logs (which are immutable).

Compensation: SREs who navigate this tension (technical chops + risk communication) command +15–25% premium.

Cited Resources Summary (50+ URLs)

  1. Google SRE Book
  2. Google SRE: Service Level Objectives
  3. Google SRE: Error Budgets
  4. Google SRE: Incident Response
  5. Kubernetes Official Documentation
  6. Linux Foundation CKA Certification
  7. Killer.sh CKA Simulator
  8. A Cloud Guru Kubernetes
  9. CNCF Cloud Native Computing Foundation
  10. CNCF 2024 Kubernetes Adoption Survey
  11. HashiCorp Terraform
  12. HashiCorp Learn Terraform
  13. Terraform Associate 003 Certification
  14. Prometheus Monitoring
  15. Grafana Visualization
  16. Datadog Observability
  17. Datadog Certification
  18. OpenTelemetry
  19. Jaeger Distributed Tracing
  20. AWS Certified Solutions Architect Associate
  21. AWS Certified DevOps Engineer Professional
  22. Google Cloud Certified Professional DevOps Engineer
  23. Azure DevOps Engineer Expert
  24. ArgoCD GitOps
  25. Flux GitOps
  26. Netflix Chaos Monkey
  27. LitmusChaos
  28. Gremlin Chaos Engineering
  29. Principles of Chaos
  30. PagerDuty Incident Response Guide
  31. PagerDuty On-Call Burnout
  32. Gartner Platform Engineering
  33. Backstage Developer Portal
  34. Crossplane Kubernetes-Native IaC
  35. Levels.fyi Salary Data
  36. PayScale DevOps Engineer Salaries
  37. Glassdoor DevOps Salaries
  38. LinkedIn Salary Database
  39. Flexera State of the Cloud 2024
  40. AWS EKS Documentation
  41. Google GKE Documentation
  42. Azure AKS Documentation
  43. AWS CloudFormation
  44. Pulumi Infrastructure as Code
  45. Helm Kubernetes Package Manager
  46. Kustomize Kubernetes Configuration
  47. Kubernetes Operators
  48. Service Mesh (Istio)
  49. Network Policy Kubernetes
  50. Pod Security Policy
  51. RBAC Kubernetes
  52. ELK Stack
  53. Canonical Careers
  54. GitLab Careers
  55. HashiCorp Careers
  56. Principles of Chaos Engineering
  57. The Phoenix Project book
  58. Release It! book
  59. Kubernetes in Action book
  60. CNCF Landscape
Rate this article
…
Was this helpful?
Comments (—)
0/2000