What a Lead } should know

Establishes performance budgets for critical services. Conducts reviews focused on latency-sensitive algorithms. Implements benchmarking and capacity testing in CI for regression detection.

Defines async standards for SRE tooling: asyncio for mass endpoint polling, concurrent health checks, parallel remediation scripts. Implements timeouts and circuit breakers in automation.

Establishes SRE code quality standards: linting for Terraform/HCL, policy testing (OPA), unit tests for automation scripts. Implements code review for infrastructure changes.

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.

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.

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).

Defines Kafka strategy for observability: metrics streaming pipeline, log aggregation, event-driven incident management. Implements Kafka infrastructure monitoring as a critical component.

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.

Defines SRE platform caching strategy: Redis for alert state management, distributed locking, session cache for internal tools. Establishes SLA and monitoring for Redis infrastructure.

Defines PostgreSQL standards: HA configurations, backup/recovery SLA, monitoring checklist. Conducts capacity planning and failure mode analysis. Plans PostgreSQL upgrades with zero-downtime.

Defines SRE platform API standards: OpenAPI for internal tools, versioning strategy, rate limiting. Implements API-first approach for SRE automation.

Defines AWS strategy: Landing Zone, account structure, cost management. Implements Well-Architected Framework reviews. Coordinates cloud operations between SRE and product teams.

Defines organizational container standards: base image policy, vulnerability management SLA, runtime configuration guidelines. Implements container observability and security scanning in CI.

Defines Helm standards: chart structure, templating best practices, review process. Coordinates chart development between SRE and product teams. Implements automated chart upgrades.

Defines K8s standards: cluster configuration baselines, security hardening, upgrade procedures. Implements policy engines (Kyverno/OPA Gatekeeper). Coordinates cluster lifecycle management.

Defines K8s core standards: namespace strategy, label/annotation conventions, resource limits guidelines. Implements admission webhooks for policy enforcement. Conducts capacity planning.

Defines LB standards: health check requirements, failover procedures, capacity planning. Implements automated traffic management. Conducts load testing and failure mode analysis.

Defines network standards: security baselines, network segmentation policy, monitoring requirements. Implements network performance budgets and automated testing.

Defines IaC standards: module registry, review process, change management. Implements policy-as-code (Sentinel/OPA). Coordinates Terraform adoption between teams.

Defines VPN standards: encryption requirements, tunnel monitoring SLA, access policies. Coordinates VPN infrastructure between cloud and on-premise. Implements automated provisioning.

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.

Defines CI/CD standards: deployment policies, approval workflows, rollback procedures. Implements deployment metrics (DORA). Coordinates deployment practices between teams.

Defines GitOps strategy for SRE: standardizes deployment safety through GitOps gates (SLO check, chaos test, security scan), designs change management through Git. Creates GitOps runbook automation for common incident response actions.

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.

Defines incident management standards: severity matrix, communication templates, post-mortem requirements. Implements incident metrics (MTTD, MTTR). Trains teams on incident response.

Defines infrastructure security standards: hardening baselines, vulnerability SLA, security monitoring requirements. Coordinates with security team. Conducts threat modeling for infrastructure.

Defines secrets management standards: Vault architecture, access policies, rotation schedule. Implements secret scanning in CI. Coordinates secrets infrastructure between teams.

Implements Copilot in SRE team: usage boundaries (configs yes, security policies — review), best practices for infrastructure code generation. Evaluates ROI and security risks.

Defines capacity planning process: periodic reviews, headroom policy, growth budgets. Coordinates capacity requests between teams. Implements automated capacity reporting.

Defines organizational DR standards: tiered recovery model, mandatory DR testing schedule, communication plan. Coordinates cross-team DR drills. Implements DR metrics.

Defines scalability standards: performance budgets, mandatory load testing, architecture review for high-load. Coordinates capacity planning. Establishes best practices for scaling.

Defines reliability architecture standards: mandatory design reviews, failure budget, architecture templates. Conducts architecture reviews focused on failure modes and scalability.

Defines APM strategy: Datadog vs New Relic vs open-source (OTel + backends), feature comparison, cost analysis. Implements APM for critical services. Defines instrumentation requirements.

Defines profiling standards: always-on profiling (Pyroscope/Parca), CPU/memory flame graphs, production profiling safety. Implements profiling-driven optimization workflow.

Defines SRE metrics standards: mandatory SLI metrics, dashboard templates, alerting best practices. Implements metric catalogs and automated cardinality monitoring.

Defines ELK standards: log format requirements, retention policies, access control. Implements cost management (hot/warm/cold nodes). Coordinates centralized logging.

Defines Loki standards: label strategy (low cardinality), retention policies, query patterns. Implements Loki for cost-effective log aggregation. Compares Loki vs ELK by scenarios.

Defines tracing standards: mandatory spans, sampling rates, retention policies. Implements Tempo/Jaeger for distributed tracing. Uses traces for dependency mapping and bottleneck analysis.

Defines on-call standards: rotation policies, compensation, workload balance. Implements on-call metrics (interruptions, sleep impact). Builds sustainable on-call culture.

Defines OTel standards: collector configuration, resource attributes policy, instrumentation requirements per service. Implements observability-as-code approach.

Defines metrics standards: mandatory metrics per service, naming conventions, dashboard templates. Manages Prometheus infrastructure costs. Coordinates monitoring adoption.

Defines organizational SLO standards: SLO requirements per tier, error budget governance, SLO review cadence. Trains teams on SRE practices. Coordinates SLO adoption.

Defines organizational logging standards: mandatory fields, format specification, privacy compliance. Implements automated log quality checks. Establishes logging best practices.

Shapes review culture: defines checklist for infra review (security, reliability, cost), review time SLA. Automates checks (tfsec, conftest, kube-linter).

Shapes Git workflow for SRE: GitOps standards, PR review requirements for infra changes, automated checks. Defines mono vs multi-repo strategy for infrastructure.

Defines latency standards: performance budgets per endpoint, mandatory profiling, latency regression policy. Implements SLO-based latency tracking and automated alerting.