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.
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.
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.
Implements Copilot in SRE team: usage boundaries (configs yes, security policies — review), best practices for infrastructure code generation. Evaluates ROI and security risks.
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.
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.
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.
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.
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.
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.
Defines auth operations standards: certificate lifecycle management, token policies, auth monitoring requirements. Coordinates with security team.
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.
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.
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.
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.
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.
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.
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.
Designs high-concurrency SRE systems: parallel fleet management, concurrent configuration rollouts, lock-free metrics aggregation pipelines. Defines concurrency models for platform tooling.
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.
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.
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.
Defines database performance standards: query latency budgets, monitoring requirements, escalation procedures. Implements automated optimization.
Distributed Tracing
▼
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.
Defines OTel standards: collector configuration, resource attributes policy, instrumentation requirements per service. Implements observability-as-code approach.
Designs OpenTelemetry platform: vendor-neutral observability, multi-signal correlation, OTel Collector scalability. Defines observability strategy and vendor evaluation.
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.
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.
Shapes Git workflow for SRE: GitOps standards, PR review requirements for infra changes, automated checks. Defines mono vs multi-repo strategy for infrastructure.
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).
Defines reliability standards for GraphQL: SLO requirements, monitoring coverage, capacity planning. Coordinates with development teams.
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.
Defines IaC standards: module registry, review process, change management. Implements policy-as-code (Sentinel/OPA). Coordinates Terraform adoption between teams.
Designs organizational IaC strategy: Terraform vs Pulumi vs Crossplane, self-service infrastructure, multi-cloud abstractions. Defines governance for infrastructure changes.
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).
Defines secrets management standards: Vault architecture, access policies, rotation schedule. Implements secret scanning in CI. Coordinates secrets infrastructure between teams.
Designs secrets management strategy: multi-cluster Vault, cross-cloud secrets, zero-trust credential issuance. Defines organizational secrets governance and compliance framework.
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.
Implements SRE integration testing standards: mandatory failover tests, monitoring validation, change verification procedures.
Kubernetes & Orchestration
▼
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.
Defines K8s core standards: namespace strategy, label/annotation conventions, resource limits guidelines. Implements admission webhooks for policy enforcement. Conducts capacity planning.
Designs organizational Kubernetes strategy: managed vs self-hosted, multi-tenancy model, cost allocation. Defines platform abstractions on top of K8s for product teams.
Logging
▼
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).
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.
Defines memory management standards: container resource limits policies, memory monitoring requirements, incident response for OOM. Conducts capacity reviews.
Metrics & 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.
Defines metrics standards: mandatory metrics per service, naming conventions, dashboard templates. Manages Prometheus infrastructure costs. Coordinates monitoring adoption.
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.
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.
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.
Defines latency standards: performance budgets per endpoint, mandatory profiling, latency regression policy. Implements SLO-based latency tracking and automated alerting.
Designs latency optimization strategy: global edge deployment, predictive caching, network optimization. Defines organizational performance culture and latency governance.
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.
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.
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.
Defines SRE platform API standards: OpenAPI for internal tools, versioning strategy, rate limiting. Implements API-first approach for SRE automation.
System Design
▼
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.
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.
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.
Defines SRE testing standards: mandatory tests for automation, alerting validation, runbook testing. Implements quality gates for infrastructure changes.