Select your current position

Pick a role and level — we'll show the growth path, skills and gap analysis.

Development path

Junior

0-2 years

Current

Responsibility: Monitoring SLI/SLO. Participating in on-call rotation. Writing runbooks. Automating routine operations. Incident analysis.

Key skills:

APM Tools Need
ArgoCD Need
Capacity Planning Need
Chaos Engineering Need
Continuous Profiling Need
Disaster Recovery Design Need
GitOps Practices Need
Grafana Loki Need
Helm Need
High Load Architecture Need
Jaeger / Grafana Tempo Need
Kubernetes Advanced Need
VPN & Network Isolation Need
Load Balancing Need
Custom Business Metrics Need
Incident Response Process Need
On-Call Management Need

Middle

2-5 years

Next

Responsibility: Defining SLI/SLO/SLA. Designing monitoring. Capacity planning. Automating incident response. Post-mortem analysis.

Key skills:

APM Tools Need
ArgoCD Need
Capacity Planning Need
Chaos Engineering Need
Continuous Profiling Need
Disaster Recovery Design Need
ELK Stack Need
GitOps Practices Need
Grafana Loki Need
Helm Need
High Load Architecture Need
Jaeger / Grafana Tempo Need
Kubernetes Advanced Need
Latency Optimization Need
Python Web Frameworks Need
Secrets Management Need
VPN & Network Isolation Need
Load Balancing Need
Custom Business Metrics Need
Incident Response Process Need
On-Call Management Need

Senior

5-8 years

Responsibility: Designing highly available systems. Chaos engineering. Performance engineering. Error budgets. Coordination with development.

Key skills:

Apache Kafka Need
APM Tools Need
ArgoCD Need
Capacity Planning Need
Chaos Engineering Need
Continuous Profiling Need
Disaster Recovery Design Need
ELK Stack Need
GitOps Practices Need
Grafana Loki Need
Helm Need
High Load Architecture Need
Jaeger / Grafana Tempo Need
Kubernetes Advanced Need
Latency Optimization Need
OpenTelemetry Need
Python Web Frameworks Need
Secrets Management Need
SLI / SLO / SLA Need
Terraform Need
VPN & Network Isolation Need
Load Balancing Need
Custom Business Metrics Need
Multithreading Need
Incident Response Process Need
On-Call Management Need

Lead / Staff

7-12 years

Responsibility: SRE strategy. Reliability culture. SLO standards. Incident management processes. Coordination with product.

Key skills:

Apache Kafka Need
APM Tools Need
ArgoCD Need
Capacity Planning Need
Chaos Engineering Need
Continuous Profiling Need
Disaster Recovery Design Need
ELK Stack Need
GitOps Practices Need
Grafana Loki Need
Helm Need
High Load Architecture Need
Jaeger / Grafana Tempo Need
Kubernetes Advanced Need
Kubernetes Core Need
Latency Optimization Need
OpenTelemetry Need
Python Web Frameworks Need
Redis Need
Secrets Management Need
SLI / SLO / SLA Need
Terraform Need
VPN & Network Isolation Need
Load Balancing Need
Custom Business Metrics Need
Multithreading Need
Network Fundamentals Need
Incident Response Process Need
On-Call Management Need

Principal

10+ years

Responsibility: Enterprise reliability strategy. Multi-region architecture. SRE culture at scale. Industry best practices.

Key skills:

Apache Kafka Need
APM Tools Need
ArgoCD Need
Capacity Planning Need
Chaos Engineering Need
Continuous Profiling Need
Disaster Recovery Design Need
ELK Stack Need
GitOps Practices Need
Grafana Loki Need
Helm Need
High Load Architecture Need
Jaeger / Grafana Tempo Need
Kubernetes Advanced Need
Kubernetes Core Need
Latency Optimization Need
OpenTelemetry Need
Python Web Frameworks Need
Redis Need
Secrets Management Need
SLI / SLO / SLA Need
Terraform Need
VPN & Network Isolation Need
Load Balancing Need
Custom Business Metrics Need
Multithreading Need
Network Fundamentals Need
Incident Response Process Need
On-Call Management Need

Gap analysis: skills to develop

To reach the next level you'll need to develop:

APM Tools

Configures APM instrumentation across microservices for production monitoring. Creates dashboards tracking golden signals and SLI compliance. Participates in on-call rotation using APM data to triage and resolve incidents.

ArgoCD

Independently configures ArgoCD for reliable service deployments with health checks, sync windows, and automated rollback on SLO violations. Writes ApplicationSets for consistent infrastructure deployment across reliability zones and regions. Implements ArgoCD monitoring with Prometheus metrics, alerting on sync failures, and integration with incident management workflows.

Capacity Planning

Conducts capacity planning for services: trend analysis, growth prediction, resource right-sizing. Configures HPA/VPA. Creates capacity dashboards. Plans seasonal load changes.

Chaos Engineering

Conducts chaos experiments for SLO validation: creates hypothesis-driven experiments with clear steady-state metrics, uses Chaos Mesh/Litmus for Kubernetes failures. Analyzes impact on SLIs and determines remediation actions based on findings.

Continuous Profiling

Configures Continuous Profiling for services. Creates dashboards and alerts. Participates in on-call rotation. Analyzes incidents.

Disaster Recovery Design

Implements DR solutions: automated backups, cross-region replication, failover testing. Documents DR plans. Configures backup monitoring and alerting on backup failures.

ELK Stack

Configures ELK pipeline: Filebeat/Fluentbit for collection, Logstash for parsing and enrichment, index patterns in Elasticsearch. Creates Kibana dashboards for operational monitoring.

GitOps Practices

Applies GitOps for SRE tasks: configures monitoring and alerting through GitOps (Prometheus rules as code), manages SLO definitions in Git, implements emergency procedures through Git-based runbooks. Ensures observability for GitOps sync status.

Grafana Loki

Configures Loki for multi-tenant log aggregation across services. Creates advanced LogQL queries with metric extraction for SLI tracking. Builds alerting rules on log patterns and participates in on-call rotation using log-based diagnostics.

Helm

Creates Helm charts for SRE tools: custom exporters, alerting rules, dashboards-as-code. Manages dependencies and chart repositories. Configures environments through value overrides.

High Load Architecture

Maintains high-load systems: autoscaling policies, connection pool tuning, cache optimization. Conducts load testing (k6, Locust). Diagnoses bottlenecks through profiling.

Jaeger / Grafana Tempo

Configures Jaeger / Grafana Tempo for services. Creates dashboards and alerts. Participates in on-call rotation. Analyzes incidents.

Kubernetes Advanced

Administers Kubernetes: RBAC, network policies, resource quotas. Configures HPA/VPA for autoscaling. Diagnoses complex issues: CrashLoopBackOff, evictions, networking issues.

Latency Optimization

Diagnoses latency issues: distributed tracing for bottleneck detection, flame graphs for CPU profiling, connection pool analysis. Optimizes: caching, connection reuse, async processing.

Python Web Frameworks

Independently implements tasks with Python Web Frameworks in Kubernetes/Terraform. Understands internals and optimizes performance. Writes tests using chaos engineering.

Secrets Management

Manages Vault: configures secret engines (KV, database, PKI), auth methods (K8s, OIDC). Rotates secrets. Integrates Vault with CI/CD and Kubernetes (CSI driver, injector).

VPN & Network Isolation

Manages VPN infrastructure: IPSec tunnels, WireGuard for internal connectivity, split tunneling. Monitors tunnel health and latency. Configures failover between VPN endpoints.

Load Balancing

Manages load balancers: target groups, weighted routing, TLS termination. Configures advanced health checks. Implements canary deployments through traffic shifting. Diagnoses 502/503 errors.

Custom Business Metrics

Designs custom metrics: SLI metrics for SLO tracking, detailed latency histograms, business metrics. Configures recording rules for aggregation. Creates alerting on custom metrics.

Incident Response Process

Manages incidents: severity classification, stakeholder communication, cross-team coordination. Conducts root cause analysis. Leads post-mortems with actionable follow-ups.

On-Call Management

Manages on-call process: configures PagerDuty schedules and escalation policies, writes runbooks for typical alerts. Analyzes on-call burden: toil, alert quality, false positive rate.