These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses AI for SRE tasks: log analysis, incident troubleshooting, runbook generation. Verifies AI recommendations before applying in production.
Applies LLM for SRE: automated incident analysis, root cause suggestion, runbook generation. Critically evaluates AI suggestions for infrastructure changes.
Integrates AI into SRE operations: AIOps for anomaly detection, intelligent alerting, automated incident response drafts. Defines AI automation boundaries.
Defines AI strategy for SRE: AIOps tool selection, automated analysis pipelines, AI-assisted incident response. Trains team on effective usage.
Uses Cursor IDE for SRE: AI-assisted Terraform/Python automation writing, auto-completion for cloud SDK. Accelerates monitoring config writing.
Configures Cursor for SRE workflow: custom rules for IaC patterns, multi-file editing for Terraform modules. Integrates with infrastructure CLI tools.
Optimizes Cursor for SRE team: shared configurations, prompts for reliability patterns, integration with SRE-specific tools.
Defines AI IDE standards for SRE: approved configurations, security policies for infrastructure code. Trains team on effective usage.
Uses Copilot for SRE tasks: generating Terraform configs, Kubernetes manifests, shell scripts for automation. Understands when suggestions are correct for infrastructure code.
Works productively with Copilot: generates Helm values, Prometheus alerting rules, Python scripts for automation. Uses Chat for error log analysis and troubleshooting.
Maximizes productivity: generating complex Terraform modules, K8s operators, monitoring dashboards-as-code. Workflow: AI for boilerplate, engineer for architecture and security review.
Implements Copilot in SRE team: usage boundaries (configs yes, security policies — review), best practices for infrastructure code generation. Evaluates ROI and security risks.
Alerting & On-Call
▼
Understands SLI/SLO/SLA: availability, latency, error rate as indicators. Monitors SLO dashboards. Understands error budgets. Responds to SLO burn rate alerts.
Defines SLIs for services: availability (successful requests / total), latency (p99 < threshold), quality. Configures SLO tracking in Prometheus/Grafana. Calculates error budgets.
Designs SLO framework: multi-window burn rate alerting, SLO-based pages, error budget policies. Implements automated SLO reporting. Integrates SLO with deployment decisions.
Defines organizational SLO standards: SLO requirements per tier, error budget governance, SLO review cadence. Trains teams on SRE practices. Coordinates SLO adoption.
Algorithms & Data Structures
▼
Understands basic algorithmic concepts for SRE: simple metric aggregation, basic alert threshold evaluation, log filtering and sorting. Follows team guidance on algorithm selection for monitoring and operational automation scripts.
Independently applies algorithmic thinking in SRE: evaluates alerting algorithm sensitivity trade-offs, selects load balancing algorithms for traffic distribution, understands capacity prediction algorithm approaches. Analyzes complexity of monitoring data processing and incident detection operations.
Applies algorithmic thinking to SRE: anomaly detection algorithms for proactive incident prevention, load shedding algorithms for graceful degradation, capacity prediction algorithms based on historical trends. Designs efficient alerting algorithms minimizing noise while maintaining detection sensitivity.
Establishes performance budgets for critical services. Conducts reviews focused on latency-sensitive algorithms. Implements benchmarking and capacity testing in CI for regression detection.
Understands basic data structures for SRE work: metric label schemas, alert rule configuration objects, runbook parameter structures. Follows team conventions for organizing monitoring configurations and incident response data.
Independently selects appropriate data structures for SRE work: metric label structures for efficient querying, alert rule data models, runbook parameter schemas. Understands trade-offs between monitoring data cardinality and query performance for observability platforms.
Selects optimal data structures for SRE tooling: time-series databases for metric storage, cardinality-efficient data structures for high-dimensional monitoring, ring buffers for recent event windows. Optimizes alert evaluation data structures for minimal latency on rule processing. Designs efficient data models for incident timeline reconstruction and post-mortem analysis.
Defines config and state modeling standards: structured configs (YAML/JSON schemas), typed metrics labels. Reviews data models for monitoring and alerting systems for cardinality concerns.
API Management
▼
Documents SRE API and tools: describes internal API endpoints, runbook procedures, monitoring setup. Writes README for infrastructure repos.
Creates SRE documentation: runbooks, architecture diagrams, on-call guides, monitoring setup docs. Automates documentation generation.
Designs documentation strategy for SRE: living runbooks, automated architecture diagrams, incident response playbooks. Introduces docs-as-code.
Defines SRE documentation standards: mandatory runbooks, postmortem templates, review process. Implements documentation culture and quality metrics.
Application Security
▼
Understands basic security practices for infrastructure: principle of least privilege, secure defaults. Follows security runbooks. Monitors security alerts from CloudWatch/GuardDuty.
Applies security in infrastructure: hardening guides for OS and containers, security scanning in CI (Trivy, Snyk), audit logging. Configures WAF rules and responds to security alerts.
Designs infrastructure security: network segmentation, runtime protection (Falco), vulnerability management pipeline. Implements security-as-code: policy enforcement, compliance scanning.
Defines infrastructure security standards: hardening baselines, vulnerability SLA, security monitoring requirements. Coordinates with security team. Conducts threat modeling for infrastructure.
Applies secure coding for SRE: never hardcodes credentials, securely manages secrets in automation. Uses vault/secrets manager in scripts.
Implements security for infrastructure code: encrypted secrets, secure CI/CD pipelines, least privilege for automation. Scans IaC through security tools.
Designs secure infrastructure automation: secrets rotation automation, secure bootstrapping, compliance-as-code. Introduces security scanning in infrastructure CI.
Defines SRE security standards: infrastructure security policies, secrets management, access control review. Implements security-as-code.
Authentication & Authorization
▼
Understands JWT/OAuth for SRE: monitors auth services, configures alerting on auth failures. Manages service account tokens for automation.
Ensures auth system reliability: monitoring token expiration, auth service SLIs, certificate management. Automates token rotation.
Designs auth reliability: HA auth infrastructure, token caching strategy, certificate automation (cert-manager). Defines auth SLO.
Defines auth operations standards: certificate lifecycle management, token policies, auth monitoring requirements. Coordinates with security team.
Caching
▼
Uses Redis at a basic level in Kubernetes/Terraform. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Redis in Kubernetes/Terraform. Understands internals and optimizes performance. Writes tests using chaos engineering.
Uses Redis for SRE tools: rate limiting for alert deduplication, distributed locks for deployments, caching for status page. Monitors Redis performance and memory usage.
Defines SRE platform caching strategy: Redis for alert state management, distributed locking, session cache for internal tools. Establishes SLA and monitoring for Redis infrastructure.
CI/CD
▼
Understands CI/CD pipeline: build, test, deploy stages. Launches and monitors pipeline runs. Debugs failed jobs through logs. Understands triggers and environments.
Configures CI/CD for infrastructure: Terraform plan/apply, Helm upgrades, container builds. Automates testing: infra unit tests, integration tests. Implements approval gates for production.
Designs CI/CD for platform: multi-stage deployments, canary/blue-green, rollback automation. Implements progressive delivery (Argo Rollouts, Flagger). Optimizes pipeline performance.
Defines CI/CD standards: deployment policies, approval workflows, rollback procedures. Implements deployment metrics (DORA). Coordinates deployment practices between teams.
Clean Code & Refactoring
▼
Understands basic code quality principles for operational scripts and monitoring configurations. Follows team conventions for alerting rule structure and runbook formatting. Writes simple, clean automation scripts for operational tasks. Accepts code review feedback on monitoring code clarity.
Independently applies code quality practices in SRE automation. Writes clean monitoring configurations, alerting rules, and runbook automation with proper error handling. Understands trade-offs between observability granularity and system overhead. Reviews operational code for alert actionability, dashboard clarity, and incident response reliability.
Designs code quality standards for SRE tooling: runbook automation structure, observability pipeline code, chaos engineering scripts. Refactors incident management automation for reliability and auditability. Establishes review practices for operational code covering error budgets, SLO monitoring, and on-call tooling.
Establishes SRE code quality standards: linting for Terraform/HCL, policy testing (OPA), unit tests for automation scripts. Implements code review for infrastructure changes.
Cloud Providers
▼
Works with AWS for SRE: EC2 for monitoring, S3 for logs, CloudWatch for basic alerts. Understands IAM, VPC, security groups. Uses AWS Console and CLI.
Administers AWS infrastructure: EKS cluster management, ALB/NLB configuration, Route53 for DNS failover. Configures CloudWatch alarms, SNS for notifications. Optimizes costs through Reserved/Spot instances.
Designs AWS platform for reliability: multi-AZ architecture, cross-region DR, AWS Organizations for multi-account. Configures GuardDuty, Config Rules for security. Automates through AWS CDK/Lambda.
Defines AWS strategy: Landing Zone, account structure, cost management. Implements Well-Architected Framework reviews. Coordinates cloud operations between SRE and product teams.
Code Review
▼
Participates in infrastructure change reviews: checks Terraform plans, Helm values, K8s manifests. Leaves constructive comments. Learns from feedback.
Conducts reviews: checks Terraform modules for security, K8s configs for reliability (resource limits, probes), networking for blast radius. Suggests best practices.
Conducts architectural review: evaluates infrastructure design, blast radius, failure modes. Reviews capacity planning, security implications, cost impact of changes.
Shapes review culture: defines checklist for infra review (security, reliability, cost), review time SLA. Automates checks (tfsec, conftest, kube-linter).
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Python/Go. Follows recommendations from senior developers when solving problems.
Independently applies async programming in SRE tooling: concurrent monitoring queries, async incident response automation, non-blocking health check orchestration. Understands trade-offs between parallel and sequential execution in operational automation.
Designs async architectures for SRE systems: concurrent monitoring at scale, async incident response orchestration, non-blocking alert correlation and routing. Mentors team on async patterns for operational system reliability.
Defines async standards for SRE tooling: asyncio for mass endpoint polling, concurrent health checks, parallel remediation scripts. Implements timeouts and circuit breakers in automation.
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Python/Go. Follows recommendations from senior developers when solving problems.
Independently applies multithreading knowledge for SRE: diagnosing thread contention and deadlock issues in production systems, analyzing thread dumps for incident resolution, tuning thread pool configurations for service performance. Explains concurrency trade-offs for reliability and throughput optimization.
Has deep expertise in diagnosing multithreading issues: analyzes thread contention and deadlock in production systems at scale, implements monitoring for concurrent system health indicators, optimizes thread configurations across service fleets. Mentors team on production concurrent system debugging and performance tuning.
Defines concurrency standards for SRE tools: thread pools for parallel deployments, lock-free metrics collection, concurrent log processing. Implements safe concurrency practices in automation scripts.
Containerization
▼
Works with Docker for SRE: runs monitoring stack (Prometheus, Grafana, AlertManager), debugs container issues. Understands layers, volumes, networking. Reads container logs.
Manages Docker in production: multi-stage builds for SRE tools, security scanning (Trivy), resource limits. Configures logging drivers, health checks. Diagnoses container runtime issues.
Designs container runtime standards: image security pipeline, registry management, runtime security (seccomp, AppArmor). Optimizes container performance: cgroup limits, OOM handling, filesystem layers.
Defines organizational container standards: base image policy, vulnerability management SLA, runtime configuration guidelines. Implements container observability and security scanning in CI.
Database Optimization
▼
Understands indexing for SRE: monitors index usage, configures alerting on missing indexes. Verifies index health through database monitoring tools.
Manages database indexing: automated index recommendations, monitoring index bloat, performance impact analysis. Configures alerting on index issues.
Designs index monitoring strategy: automated missing index detection, index maintenance schedules, performance regression alerting.
Defines database indexing standards for operations: monitoring requirements, maintenance procedures, escalation policies. Coordinates with DBA.
Understands query optimization for SRE: monitors slow queries, configures alerting on performance degradation. Uses database monitoring tools.
Optimizes database performance: automated slow query detection, query plan analysis, connection pool monitoring. Configures performance dashboards.
Designs database performance monitoring: automated query analysis, performance regression detection, capacity planning tools. Defines performance SLO.
Defines database performance standards: query latency budgets, monitoring requirements, escalation procedures. Implements automated optimization.
Distributed Tracing
▼
Understands the fundamentals of Jaeger / Grafana Tempo. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Configures Jaeger / Grafana Tempo for services. Creates dashboards and alerts. Participates in on-call rotation. Analyzes incidents.
Designs observability strategy with Jaeger / Grafana Tempo. Implements distributed tracing. Defines SLI/SLO. Conducts post-mortems.
Defines tracing standards: mandatory spans, sampling rates, retention policies. Implements Tempo/Jaeger for distributed tracing. Uses traces for dependency mapping and bottleneck analysis.
Understands OpenTelemetry: traces, metrics, logs — three pillars of observability. Connects auto-instrumentation to services. Views traces in Jaeger/Tempo. Understands context propagation.
Configures OpenTelemetry: collector deployment (sidecar/daemonset), processor pipeline, exporter configuration. Adds custom spans and attributes. Integrates traces + metrics + logs.
Designs OTel architecture: collector fleet management, sampling strategies, tail-based sampling. Optimizes overhead and storage costs. Implements custom processors for enrichment.
Defines OTel standards: collector configuration, resource attributes policy, instrumentation requirements per service. Implements observability-as-code approach.
DNS & Networking
▼
Understands load balancing: Layer 4 vs Layer 7, health checks, round-robin. Configures ALB/NLB in AWS. Monitors load balancer metrics: request count, latency, error rate.
Manages load balancers: target groups, weighted routing, TLS termination. Configures advanced health checks. Implements canary deployments through traffic shifting. Diagnoses 502/503 errors.
Designs load balancing architecture: global load balancing (Route53, Cloudflare), internal LB for microservices, gRPC balancing. Optimizes connection draining, session affinity, retry policies.
Defines LB standards: health check requirements, failover procedures, capacity planning. Implements automated traffic management. Conducts load testing and failure mode analysis.
Understands VPN for secure connectivity: site-to-site for data centers, client VPN for remote access. Configures and tests VPN connections. Diagnoses connection issues.
Manages VPN infrastructure: IPSec tunnels, WireGuard for internal connectivity, split tunneling. Monitors tunnel health and latency. Configures failover between VPN endpoints.
Designs VPN architecture: hub-and-spoke vs mesh, Transit Gateway VPN attachments, automated tunnel management. Optimizes throughput. Plans migration to zero-trust (BeyondCorp).
Defines VPN standards: encryption requirements, tunnel monitoring SLA, access policies. Coordinates VPN infrastructure between cloud and on-premise. Implements automated provisioning.
E2E Testing
▼
Tests SRE tools end-to-end: verifies full incident response flow, monitoring → alerting → notification pipeline. Participates in game days.
Designs e2e tests for SRE: disaster recovery drills, failover testing, monitoring validation. Automates reliability validation in CI.
Defines SRE e2e testing strategy: chaos engineering, game day framework, production readiness testing. Implements automated reliability validation.
Implements e2e testing standards: mandatory DR drills, game day cadence, failover testing requirements. Defines testing infrastructure.
Git & Workflows
▼
Works with Git for infrastructure: commit, push, pull for Terraform, K8s manifests, configs. Follows team GitOps workflow. Writes clear commit messages.
Uses Git for IaC: feature branches, rebasing, squash for clean history. Works with mono-repo for infrastructure. Configures git hooks for terraform fmt, yaml lint.
Defines Git strategy for infrastructure: trunk-based for configs, release branches for infrastructure versions. Configures branch protection, CODEOWNERS for critical infrastructure.
Shapes Git workflow for SRE: GitOps standards, PR review requirements for infra changes, automated checks. Defines mono vs multi-repo strategy for infrastructure.
GitOps
▼
Understands basic ArgoCD concepts for managing service deployments and infrastructure reconciliation. Follows team runbooks for checking Application sync status, identifying out-of-sync resources during incidents, and verifying deployment health. Uses ArgoCD UI and CLI to observe deployment states and correlate sync events with service availability issues.
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.
Designs ArgoCD architecture for highly available service delivery with multi-cluster failover and disaster recovery patterns. Implements GitOps-driven reliability practices including automated canary analysis, SLO-based deployment gates, and chaos engineering integration for deployment validation. Optimizes ArgoCD for production reliability with controller HA, webhook-driven reconciliation, and drift alerting pipelines.
Defines ArgoCD-based deployment reliability standards for the organization's service fleet. Establishes governance for deployment safety including progressive rollout policies, blast radius controls, and SLO-integrated deployment approval workflows. Conducts architecture reviews of ArgoCD configurations from a reliability perspective and drives adoption of GitOps-based incident remediation patterns.
GraphQL
▼
Understands GraphQL for SRE: monitors GraphQL services, understands query complexity. Configures health checks and alerting for GraphQL endpoints.
Ensures GraphQL reliability: performance monitoring, query depth limiting, rate limiting. Configures SLIs for GraphQL (latency, error rate).
Designs reliability for GraphQL infrastructure: caching strategy, CDN integration, federation monitoring. Defines performance budgets.
Defines reliability standards for GraphQL: SLO requirements, monitoring coverage, capacity planning. Coordinates with development teams.
Incident Management
▼
Participates in on-call: follows escalation procedures, uses PagerDuty for alert management. Documents incidents. Hands off duty with handoff notes.
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.
Optimizes on-call: alert tuning for noise reduction, automated remediation for common issues. Designs runbook automation. Analyzes on-call metrics and creates improvement plan.
Defines on-call standards: rotation policies, compensation, workload balance. Implements on-call metrics (interruptions, sleep impact). Builds sustainable on-call culture.
Incident Response
▼
Follows incident response process: escalation by severity, communication in dedicated channels. Documents incident timeline. Participates in post-mortem reviews.
Manages incidents: severity classification, stakeholder communication, cross-team coordination. Conducts root cause analysis. Leads post-mortems with actionable follow-ups.
Designs incident response process: automated severity detection, runbook automation, war room orchestration. Implements SLO-based alerting for proactive incident detection.
Defines incident management standards: severity matrix, communication templates, post-mortem requirements. Implements incident metrics (MTTD, MTTR). Trains teams on incident response.
Infrastructure as Code
▼
Uses Terraform for SRE infrastructure: EC2, VPC, S3, RDS. Understands plan/apply workflow. Reads existing modules. Follows team IaC practices.
Writes Terraform modules for monitoring infrastructure: Prometheus on EKS, Grafana Cloud, CloudWatch alarms. Manages state: remote backend, state locking. Configures CI/CD for Terraform.
Designs IaC for platform: reusable modules, composition patterns, Terragrunt for DRY configuration. Automates infrastructure drift detection. Implements blast radius reduction through workspace isolation.
Defines IaC standards: module registry, review process, change management. Implements policy-as-code (Sentinel/OPA). Coordinates Terraform adoption between teams.
Infrastructure Security
▼
Works with HashiCorp Vault for retrieving secrets: CLI for reading, environment injection through sidecar. Understands secret paths and access policies. Never hardcodes credentials.
Manages Vault: configures secret engines (KV, database, PKI), auth methods (K8s, OIDC). Rotates secrets. Integrates Vault with CI/CD and Kubernetes (CSI driver, injector).
Designs secrets management: Vault HA cluster (Raft), dynamic secrets for databases, PKI infrastructure. Automates certificate rotation. Implements audit logging and compliance monitoring.
Defines secrets management standards: Vault architecture, access policies, rotation schedule. Implements secret scanning in CI. Coordinates secrets infrastructure between teams.
Integration Testing
▼
Tests SRE tool integration: verifies alerting → PagerDuty connectivity, monitoring stack connectivity. Uses test environments for validation.
Designs integration tests for SRE: monitoring pipeline testing, alerting rules validation, deployment verification. Automates in CI/CD.
Defines integration testing strategy: end-to-end monitoring validation, disaster recovery testing, failover verification. Introduces game days.
Implements SRE integration testing standards: mandatory failover tests, monitoring validation, change verification procedures.
Kubernetes & Orchestration
▼
Installs and updates Helm charts: Prometheus stack, Grafana, Loki, cert-manager. Understands values.yaml, release management. Debugs failed deployments through helm status.
Creates Helm charts for SRE tools: custom exporters, alerting rules, dashboards-as-code. Manages dependencies and chart repositories. Configures environments through value overrides.
Designs Helm strategy: library charts for shared components, umbrella charts for full stack deployment. Automates chart testing (helm unittest, ct lint). Implements GitOps workflow for Helm releases.
Defines Helm standards: chart structure, templating best practices, review process. Coordinates chart development between SRE and product teams. Implements automated chart upgrades.
Works with Kubernetes for SRE: kubectl for diagnostics, pod logs, describe for troubleshooting. Understands deployments, services, configmaps. Follows runbooks during incidents.
Administers Kubernetes: RBAC, network policies, resource quotas. Configures HPA/VPA for autoscaling. Diagnoses complex issues: CrashLoopBackOff, evictions, networking issues.
Designs Kubernetes reliability: pod disruption budgets, topology spread constraints, custom operators for automation. Configures multi-zone deployment, graceful shutdown. Optimizes cluster performance.
Defines K8s standards: cluster configuration baselines, security hardening, upgrade procedures. Implements policy engines (Kyverno/OPA Gatekeeper). Coordinates cluster lifecycle management.
Understands basic K8s concepts: pods, deployments, services, namespaces. Deploys monitoring stack through kubectl/Helm. Reads pod logs and events for troubleshooting.
Manages K8s resources: ConfigMaps for configuration, Secrets management, Ingress for routing. Configures liveness/readiness probes. Understands scheduling: nodeSelector, affinity, tolerations.
Designs K8s infrastructure for reliability: StatefulSets for stateful workloads, DaemonSets for node-level monitoring, Jobs/CronJobs for maintenance. Configures service mesh (Istio/Linkerd).
Defines K8s core standards: namespace strategy, label/annotation conventions, resource limits guidelines. Implements admission webhooks for policy enforcement. Conducts capacity planning.
Logging
▼
Uses Kibana for log search: KQL queries, filtering by level and service. Creates saved searches for common issues. Understands log entry structure.
Configures ELK pipeline: Filebeat/Fluentbit for collection, Logstash for parsing and enrichment, index patterns in Elasticsearch. Creates Kibana dashboards for operational monitoring.
Designs ELK architecture: cluster sizing, ILM for retention management, cross-cluster search. Optimizes: index templates, mapping, ingest pipelines. Configures alerting through ElastAlert.
Defines ELK standards: log format requirements, retention policies, access control. Implements cost management (hot/warm/cold nodes). Coordinates centralized logging.
Uses Grafana Loki to search and filter logs during incident investigation. Understands log retention policies and storage concepts. Follows runbooks that reference Loki queries for common troubleshooting scenarios.
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.
Designs the organization-wide logging strategy with Loki as the centralized log platform. Defines SLI/SLO based on log-derived metrics and automates error-budget alerting. Leads post-mortems leveraging Loki correlation with distributed traces and APM data.
Defines Loki standards: label strategy (low cardinality), retention policies, query patterns. Implements Loki for cost-effective log aggregation. Compares Loki vs ELK by scenarios.
Configures structured logging: JSON format, mandatory fields (timestamp, level, service, trace_id). Understands log levels. Does not log sensitive data.
Designs logging pipeline: structured JSON logs, correlation ID propagation, log enrichment (metadata). Integrates logging with tracing. Configures log shipping (Fluentbit/Vector).
Designs logging architecture: unified log format for all services, sampling strategy for high-volume, log-based metrics extraction. Integrates with OpenTelemetry logs API.
Defines organizational logging standards: mandatory fields, format specification, privacy compliance. Implements automated log quality checks. Establishes logging best practices.
Memory Management
▼
Understands memory management for SRE: monitors memory usage, configures OOM alerting. Diagnoses memory leaks through basic tools.
Manages memory in production: container memory limits, swap management, memory leak detection. Configures dashboards and alerting for memory metrics.
Designs memory monitoring strategy: JVM/runtime-specific memory tracking, automated leak detection, capacity planning. Defines memory budgets.
Defines memory management standards: container resource limits policies, memory monitoring requirements, incident response for OOM. Conducts capacity reviews.
Message Queues & Event Streaming
▼
Uses Apache Kafka at a basic level in Kubernetes/Terraform. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Apache Kafka in Kubernetes/Terraform. Understands internals and optimizes performance. Writes tests using chaos engineering.
Uses Kafka for SRE tasks: streaming metrics processing, alert aggregation, audit log collection. Configures consumer groups for distributed alert processing. Monitors Kafka cluster health.
Defines Kafka strategy for observability: metrics streaming pipeline, log aggregation, event-driven incident management. Implements Kafka infrastructure monitoring as a critical component.
Metrics & Monitoring
▼
Creates custom metrics: application counters, business KPIs through Prometheus client libraries. Understands RED metrics (Rate, Errors, Duration) and USE (Utilization, Saturation, Errors).
Designs custom metrics: SLI metrics for SLO tracking, detailed latency histograms, business metrics. Configures recording rules for aggregation. Creates alerting on custom metrics.
Defines metrics framework: standard instrumentation library, metric naming conventions, cardinality management. Implements derived metrics through recording rules. Integrates with SLO tooling.
Defines SRE metrics standards: mandatory SLI metrics, dashboard templates, alerting best practices. Implements metric catalogs and automated cardinality monitoring.
Works with Prometheus/Grafana: reads metrics, creates basic dashboards. Understands metric types: counter, gauge, histogram, summary. Configures simple alerting rules.
Configures Prometheus monitoring: service discovery, recording rules for aggregates, alerting rules with proper severity. Creates comprehensive Grafana dashboards. Configures AlertManager routing.
Designs Prometheus architecture: federation, Thanos/Mimir for long-term storage and global view. Optimizes cardinality, retention. Implements multi-cluster monitoring.
Defines metrics standards: mandatory metrics per service, naming conventions, dashboard templates. Manages Prometheus infrastructure costs. Coordinates monitoring adoption.
Networking
▼
Understands networking basics for SRE: TCP/IP, DNS, HTTP. Diagnoses network issues: ping, traceroute, dig, curl. Understands VPC, subnets, security groups.
Diagnoses network issues: MTU issues, connection timeouts, DNS resolution failures. Configures network monitoring: packet loss, latency. Understands CDN, reverse proxy, TLS termination.
Designs network reliability: multi-AZ networking, failover strategies, BGP for multi-homing. Optimizes network performance: connection pooling, keep-alive tuning, TCP optimization.
Defines network standards: security baselines, network segmentation policy, monitoring requirements. Implements network performance budgets and automated testing.
OOP & Design Patterns
▼
Applies patterns in SRE context: Circuit Breaker for resilience, Retry for fault tolerance. Understands architectural patterns for reliable systems.
Uses reliability patterns: Bulkhead for isolation, Saga for distributed recovery, Sidecar for observability. Implements self-healing patterns.
Designs reliability architecture: cell-based architecture, shuffle sharding, backpressure patterns. Combines patterns for multi-layer resilience.
Defines reliability patterns for the organization: pattern catalog, reference architectures for resilience. Conducts design reviews focused on reliability.
Understands basic OOP concepts in Python/Go: classes, interfaces, struct composition. Applies simple SOLID principles when writing operational automation tools. Follows team patterns for monitoring client classes and runbook automation module structure.
Independently applies OOP/SOLID in SRE tooling and automation: proper abstraction for monitoring clients, interface-based alerting backends, single responsibility in runbook automation modules. Understands trade-offs between OOP patterns and scripting approaches for operational tooling.
Applies OOP/SOLID in SRE tooling architecture: abstract interfaces for monitoring backends, strategy pattern for alert routing, template method for standardized runbook automation. Designs extensible observability frameworks with clean separation between data collection, processing, and alerting layers.
Defines SRE tooling code standards: modular health checks, abstract provider interfaces for multi-cloud. Trains team on infrastructure automation patterns (Strategy for different clouds, Template for runbooks).
Optimization
▼
Understands latency: p50, p95, p99 percentiles. Monitors latency through dashboards. Identifies slow endpoints. Understands impact of networking, DB queries, external calls on latency.
Diagnoses latency issues: distributed tracing for bottleneck detection, flame graphs for CPU profiling, connection pool analysis. Optimizes: caching, connection reuse, async processing.
Designs low-latency architecture: CDN placement, edge caching, connection pooling optimization, tail-latency management. Implements per-service latency budgets. Implements automated regression detection.
Defines latency standards: performance budgets per endpoint, mandatory profiling, latency regression policy. Implements SLO-based latency tracking and automated alerting.
Profiling
▼
Navigates APM dashboards to check service health and error rates. Understands basic metrics like latency, throughput, and error percentages. Escalates anomalies detected via APM alerts to senior engineers.
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.
Architects the observability platform integrating APM, logging, and tracing. Defines SLI/SLO for critical services and automates error-budget tracking. Leads post-mortem processes and drives reliability improvements based on APM insights.
Defines APM strategy: Datadog vs New Relic vs open-source (OTel + backends), feature comparison, cost analysis. Implements APM for critical services. Defines instrumentation requirements.
Understands the fundamentals of Continuous Profiling. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Configures Continuous Profiling for services. Creates dashboards and alerts. Participates in on-call rotation. Analyzes incidents.
Designs observability strategy with Continuous Profiling. Implements distributed tracing. Defines SLI/SLO. Conducts post-mortems.
Defines profiling standards: always-on profiling (Pyroscope/Parca), CPU/memory flame graphs, production profiling safety. Implements profiling-driven optimization workflow.
Prompt Engineering
▼
Composes prompts for SRE tasks: error log analysis, alerting rule generation, troubleshooting guides. Formulates context for incident analysis.
Creates structured prompts: templates for incident postmortem, capacity planning analysis, runbook generation. Uses chain-of-thought for root cause analysis.
Designs prompt systems for SRE: automated incident analysis pipelines, systematic prompts for architecture review. Evaluates AI reliability.
Defines prompt standards for SRE: prompt library for incident response, evaluation criteria, security guidelines for AI in operations.
Relational Databases
▼
Writes SQL queries for SRE tasks: incident analysis, metric extraction from operational DB. Works with PostgreSQL for configuration and audit log storage. Understands basic DB monitoring.
Administers PostgreSQL for SRE: monitoring through pg_stat_statements, connection pool tuning (PgBouncer), backup verification. Configures alerting on slow queries, connection exhaustion, replication lag.
Designs PostgreSQL reliability: streaming replication setup, automated failover (Patroni), point-in-time recovery. Optimizes for operational workloads: vacuum tuning, index maintenance, connection pooling.
Defines PostgreSQL standards: HA configurations, backup/recovery SLA, monitoring checklist. Conducts capacity planning and failure mode analysis. Plans PostgreSQL upgrades with zero-downtime.
REST API
▼
Works with REST API for SRE: uses monitoring system APIs (Prometheus, PagerDuty, Grafana), automates routine operations through API. Understands HTTP codes and authentication.
Develops APIs for SRE automation: runbook endpoints, deployment triggers, health-check aggregators. Integrates through API: PagerDuty, Slack, Jira for incident management workflow.
Designs API for SRE platform: self-service infrastructure provisioning, SLO management API, incident orchestration. Implements idempotency for critical operations (rollback, scaling).
Defines SRE platform API standards: OpenAPI for internal tools, versioning strategy, rate limiting. Implements API-first approach for SRE automation.
Specialized Testing
▼
Understands chaos engineering as an SRE practice: knows the connection with error budgets (chaos for verifying system stays within SLO), understands game day format. Participates in experiments as an observer and helps document results.
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.
Designs chaos program linked with SRE practices: integrates chaos experiments into post-mortem follow-ups, creates continuous verification for critical paths. Implements sophisticated experiments: clock skew, DNS failures, TLS certificate expiry, cascading failure scenarios.
Defines chaos engineering strategy for SRE organization: creates chaos maturity assessment, designs automated resilience scoring per service. Implements chaos experiments as prerequisite for production readiness review and defines escalation procedures.
System Design
▼
Understands the fundamentals of Capacity Planning. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Conducts capacity planning for services: trend analysis, growth prediction, resource right-sizing. Configures HPA/VPA. Creates capacity dashboards. Plans seasonal load changes.
Designs capacity management: predictive scaling, load testing for capacity validation, cost-aware autoscaling. Implements automated right-sizing recommendations. Models growth scenarios.
Defines capacity planning process: periodic reviews, headroom policy, growth budgets. Coordinates capacity requests between teams. Implements automated capacity reporting.
Understands DR concepts: RPO, RTO, backup types. Follows DR procedures: failover runbooks, backup verification. Participates in DR drills.
Implements DR solutions: automated backups, cross-region replication, failover testing. Documents DR plans. Configures backup monitoring and alerting on backup failures.
Designs DR architecture: active-passive vs active-active, pilot light, warm standby. Implements automated failover. Conducts chaos engineering for DR validation. Defines RTO/RPO by tier.
Defines organizational DR standards: tiered recovery model, mandatory DR testing schedule, communication plan. Coordinates cross-team DR drills. Implements DR metrics.
Understands high-load principles: horizontal scaling, caching, load balancing. Monitors high-load metrics: RPS, latency percentiles, error rates.
Maintains high-load systems: autoscaling policies, connection pool tuning, cache optimization. Conducts load testing (k6, Locust). Diagnoses bottlenecks through profiling.
Designs high-load architecture: sharding strategies, CQRS for read-heavy workloads, queue-based decoupling. Optimizes: connection pooling, batch processing, async communication.
Defines scalability standards: performance budgets, mandatory load testing, architecture review for high-load. Coordinates capacity planning. Establishes best practices for scaling.
Understands production system architecture: load balancer → app servers → database, caching layer, message queues. Knows failure modes of each component.
Designs reliable systems: redundancy patterns (active-passive, active-active), circuit breakers, retry with backoff. Conducts failure mode analysis. Chooses sync vs async communication.
Designs distributed systems: CAP theorem trade-offs, consensus protocols, eventual consistency patterns. Defines data replication strategy. Designs cross-service communication (mesh, events).
Defines reliability architecture standards: mandatory design reviews, failure budget, architecture templates. Conducts architecture reviews focused on failure modes and scalability.
Type Systems
▼
Applies type safety in SRE code: TypeScript for automation, typed Python for tooling. Uses typed configurations (Jsonnet, CUE).
Ensures type safety in infrastructure code: typed Terraform (CDK/Pulumi), strict Python for automation, JSON Schema for configs.
Designs type-safe infrastructure: CUE for configuration validation, typed deployment pipelines, schema validation for infrastructure-as-data.
Defines SRE type safety standards: typed IaC requirements, configuration validation policies. Implements automated type checking for infrastructure code.
Unit Testing
▼
Writes unit tests for SRE tools: tests alerting rules, automation scripts, health checks. Uses pytest/jest for infrastructure code.
Tests SRE automation: unit tests for runbook scripts, alerting logic, custom exporters. Uses mocks for cloud API and infrastructure components.
Designs testing strategy for SRE: reliability tool tests, chaos engineering validation, policy-as-code testing. Introduces CI for infrastructure code.
Defines SRE testing standards: mandatory tests for automation, alerting validation, runbook testing. Implements quality gates for infrastructure changes.
Web Frameworks
▼
Uses Python Web Frameworks at a basic level in Kubernetes/Terraform. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Python Web Frameworks in Kubernetes/Terraform. Understands internals and optimizes performance. Writes tests using chaos engineering.
Develops SRE services on Flask/FastAPI: status pages, runbook automation API, custom webhook receivers for alerting integration. Implements health-check endpoints for internal tooling.
Defines SRE service standards: FastAPI for automation API, internal dashboards, incident bot backends. Chooses between Python and Go for SRE tooling by performance and maintainability.