How to become a Site Reliability Engineer (SRE) / Platform Engineer

Ideal starting backgrounds

You're ready to start this path if you can:

• Explain the difference between monitoring (metrics) and observability (metrics + logs + traces)
• Write a Python or Go script to automate an operational task
• Explain Kubernetes architecture (control plane, nodes, pods, services)
• Design a system that can tolerate failure of 1/3 of infrastructure

Not ready yet? Spend 2–3 years as a DevOps engineer first. SRE builds on DevOps foundation.

Study hours required: ~600–800 hours total (Stage 1–3). Assumes 25–30 hours/week = 20–32 weeks.

All figures: median base salary, not including bonuses/equity. ZAR = USD × 18 baseline (verified May 2026). Sources: Robert Half 2026, Glassdoor, LinkedIn Salary.

South Africa note: Entry-level SREs at tech companies earn R61,000–R90,000/month. Mid-level (3–5 years) command R100,000–R160,000/month. Remote work for international tech (Google, Amazon, Stripe) yields R140,000–R220,000/month for SA-based engineers. Startups pay lower but offer growth and equity.

Salary accelerators: All three Kubernetes certs (CKA + CKAD + CKS) command 15–25% premium. Published SRE practices, incident postmortems, and observability expertise add credibility. Open-source contributions (Kubernetes operators, monitoring tools) boost pay significantly.

Month 0–6: Build the Foundation

1. Set up your Kubernetes lab — Use Minikube, Kind, or cloud-based Kubernetes (AWS EKS, GCP GKE free tier). Deploy real applications.
2. Focus on CKA — Dedicate 12–14 weeks to mastering Kubernetes administration. Deep hands-on practice.
3. Start observability — Deploy Prometheus and Grafana in your lab. Instrument applications. Learn to read metrics.
4. Join SRE community — Reddit: r/devops, r/sre. Discord: Kubernetes, SRE communities. Follow SRE blogs (Google, Stripe, Uber).

Month 6–15: Build Your Portfolio

1. Project 1: Multi-Tier Application Deployment (10–12 hours) — Deploy a realistic app (microservices, databases, message queues) in Kubernetes. Use YAML manifests and Helm charts. Include security (RBAC, network policies). Document on GitHub.

2. Project 2: Observability Stack (12–14 hours) — Deploy Prometheus, Grafana, ELK (or Datadog). Instrument your application. Create dashboards for key metrics (latency, error rate, throughput). Write alerts for anomalies.

3. Project 3: Incident Simulation & Response (8–10 hours) — Simulate failures in your Kubernetes cluster (pod crash, node failure, disk full). Use observability tools to diagnose. Write a formal incident postmortem. This demonstrates SRE thinking.

4. Project 4: Automation Script (6–8 hours) — Write a Python or Go script to automate an operational task (e.g., cluster health checks, auto-scaling policy, cost optimisation). This shows software engineering thinking.

Month 15–22: Apply and Iterate

• CV positioning: List yourself as "SRE Engineer" or "Platform Engineer" once you have CKA + CKAD + CKS. Before that, list as "Senior DevOps Engineer" or "DevOps Engineer (SRE Track)".
• Target companies: Start with tech companies and cloud-native startups. They understand SRE roles. Then move to banks and enterprises modernising infrastructure. Avoid companies that don't understand SRE (they may call the role "DevOps" when it's actually SRE).
• Interview prep: Be ready to discuss: 1) A production incident and how you responded; 2) How you'd design for resilience; 3) Your observability architecture; 4) Kubernetes architecture and troubleshooting; 5) Incident postmortem and lessons learned; 6) Automation you've written; 7) On-call experience and alert fatigue.
• Salary negotiation: SRE roles in SA start at R61k–R90k/month. With CKA + CKAD + CKS, negotiate for R95k–R130k/month. International remote roles are R140k–R220k/month—actively target those. SRE salaries grow fast; by year 3, you'll likely be at R130k–R180k/month.

SRE Engineer at a Fintech (Johannesburg) — Junior Level

08:00 — Arrive. Check on-call alerts from overnight. One alert: elevated error rate in the payments service (3.2% vs. 0.5% baseline). Investigate using observability tools: Prometheus metrics show a spike in database query latency. Trace logs in ELK to the root cause: a new query from a feature deployment yesterday. Alert the on-call developer. They roll back the feature. Error rate drops. Good catch.

09:00 — Standup with engineering and SRE teams. Brief on overnight incident and resolution. Discuss: should we have caught this before production? How can we improve? Add to tomorrow's postmortem.

10:00 — Work on your assigned task: implement automated cluster scaling policy. Write Terraform to define auto-scaling rules (scale up if CPU > 70%, scale down if CPU < 20%). Deploy to staging. Test by generating load.

12:00 — Lunch.

13:00 — Review Kubernetes manifests from the development team. Check for best practices: resource requests/limits set? Health checks configured? Network policies in place? Request changes where needed.

14:30 — Work on observability improvements. Current alert noise: false positives on database latency alerts. Tune thresholds using historical data from Prometheus. Reduce alert count by 40%.

15:30 — Postmortem on this morning's incident. Write a formal postmortem: timeline, root cause (missing safeguard for new query), actions to prevent (code review checklist update), and follow-up tasks. Share with team.

17:00 — Wrap up. Handoff to the next on-call engineer. Close out Jira tickets.

SRE Engineer at a Major Tech Company (Remote, EMEA) — Mid-Level

09:00 — Async standup. Overnight, the platform team rolled out a new storage backend to 10% of traffic (canary deployment). Observability team (you, plus 2 others) monitored closely: latency +2% (expected, new backend is optimised), error rate flat, throughput +5% (good). Continue canary to 50% of traffic.

10:00 — Lead a design review: a team is building a new microservice. You review: how are they handling failures (circuit breakers, retries)? What are their SLOs (service level objectives)? Are they instrumenting for observability? Request changes to SLO targets and add observability checkpoints.

12:00 — Lunch + consultation call with a team. They're experiencing high tail latency (p99 is 500ms vs. p50 of 50ms). You help analyse traces in Jaeger. Find: one downstream service has outliers. Drill into logs. Root cause: specific query pattern hits a slow database index. You recommend a fix (add index, or change query). They implement.

13:00 — Work on a new observability tool: building a custom metric for "canary deployment success" (compares baseline error rates with canary error rates). Write Python code to calculate and push to Prometheus. Set up Grafana dashboard.

14:30 — Mentor a junior SRE on incident response. Walk through a historical postmortem. Teach: how to use observability tools to diagnose, how to think about root causes, and how to prevent recurrence.

16:00 — Work on automation: write a Kubernetes operator to manage certificate rotation (TLS certs expire; operator auto-renews them). Saves manual work and reduces cert expiry incidents.

17:00 — Wrap up. Check on-call alerts (none). Plan next week: prepare training on Kubernetes networking for non-SRE engineers.

Market specifics

SRE is an emerging specialisation in SA. Tech companies (Takealot, PayFast) understand SRE and are hiring. Most SA companies outside tech call the role "DevOps" when they really mean SRE. However, the distinction is growing as companies mature.

The SRE market in SA is less saturated than DevOps, creating opportunity for specialists. Companies that hire SREs pay premiums (understanding SRE requires sophistication). Remote work is excellent for SREs—tech companies globally hire SA-based SREs.

SA-specific resources

Q: How much DevOps experience do I need before becoming an SRE?

2–3 years minimum. SRE builds on DevOps foundation. You need to understand infrastructure, automation, and cloud platforms deeply before specialising in reliability and observability. Some people with strong software engineering backgrounds can transition faster (1–2 years), but most need the DevOps foundation.

Q: Do I need all three Kubernetes certs (CKA, CKAD, CKS)?

Ideally yes. CKA is mandatory. CKAD and CKS are valuable. Many SREs get hired with just CKA, then pursue CKAD/CKS while working (employer often sponsors). If budget is tight, prioritise CKA (cluster admin) → CKAD (app dev) → CKS (security).

Q: Is SRE work still on-call heavy?

Yes, but well-designed systems and good automation reduce on-call burden. A mature SRE team with excellent observability and runbooks can have 1 week per month on-call with few pages. A junior SRE team or immature systems: more on-call pain. Ask during interviews: "What's your on-call load and automation maturity?"

Q: What's the difference between SRE and DevOps?

DevOps: automation, CI/CD, infrastructure provisioning. SRE: reliability, observability, incident response, automation for operational tasks. DevOps is broad; SRE is deep + software engineering. Think: DevOps builds the infrastructure; SRE runs and improves it.

Q: Can I do this path without a strong programming background?

Harder but possible. SRE expects you to write code (Python, Go) to automate operational tasks. If you're not comfortable coding, spend 2–3 months learning a language (Python recommended) before pursuing SRE certs. However, the best SREs are strong software engineers.

Career path guide for SRE / Platform engineers | Last updated 2026-05-02 | ZAR baseline: R18/$1 USD For updates and job leads, see IT Career Roadmap