DevOps / SRE / Platform Engineer — are these the same role?

Overlapping practice, different framings. DevOps is older and broader. SRE is Google's framing — error-budget-focused, often deployed in scale-out infra. Platform Engineering is the 2026 framing — emphasizes internal-engineering-customer empathy. Pick the framing your target company uses; the underlying skill set transfers.

How important is K8s depth in 2026?

Critical at scale-out infra companies. Less critical at smaller shops or those running serverless-first (Vercel, Cloudflare Workers). For senior bar at most companies, you should be able to debug a CrashLoopBackOff that isn't the obvious one.

Cost-optimization (FinOps) — separate role or part of SRE?

In 2026, part of senior SRE. Smaller companies may have a dedicated FinOps function but most senior-IC roles include FinOps responsibility implicitly.

Will agents replace SRE work?

Compresses bottom-40% (basic alerting, runbook execution, log search). Doesn't touch top-60% (incident debugging under pressure, capacity planning, SLO design, security architecture). Senior IC SRE who shape what agents do AND debug when they go wrong are emerging as the most valuable specialty.

How do I show on-call ownership without an SRE title?

Specifics. "Held primary on-call rotation for the auth service; 4-week cycle, 11 incidents owned over 18 months." Generic "I've been on-call" reads as low-confidence.

How does Lakshya help specifically for this archetype?

Three ways: (1) the archetype detector classifies SRE / DevOps / Platform JDs cleanly into "devops-sre" — distinct from ai-platform (which has its own observability work) and backend (which has its own perf work). (2) The CV tailor reframes ops work into operationally-specific language. (3) The story bank captures incident-postmortem stories tagged "devops-sre" — every loop probes them.

archetype guide · devops-sre

How to land a DevOps / SRE role in 2026

Keep production up and the budget under control.

DevOps / SRE / Platform Engineering — three names for overlapping work that owns the runtime substrate the rest of the company depends on. The discipline matured through 2020-25; the senior-IC bar is now sharply defined: you've owned a production incident at $1M+ revenue exposure, you can read a Grafana dashboard in 30 seconds and find the root cause, and you've shipped infrastructure-as-code that other engineers actually trust.

If you've held an on-call rotation for a critical system, debugged a cascading failure under deadline, or stood up an observability stack from scratch, you're qualified. The 2026 market is healthy at the senior-IC bar; mid-level is more competitive.

Lakshya's eval corpus has 180+ A-G evaluations against DevOps / SRE / Platform roles across 110 companies. The pattern that scores 4.0+ leans heavily on incident-ownership and capacity-planning narratives.

Who hires for this role

Infra-as-product (Cloudflare, Datadog, Vercel, Sentry, Supabase, Neon, Replicate)
Fintech with stringent uptime requirements (Stripe, Plaid, Brex, Mercury, Razorpay, Cred)
Big tech (Google SRE, Meta Production Engineering, Amazon Operations, Microsoft Azure SRE)
AI infra (OpenAI Infrastructure, Anthropic Compute, AWS Bedrock backend, Modal, Together)
Productivity SaaS at scale (Notion, Linear, Slack, Atlassian, Asana platform teams)

What this archetype actually does

Senior-IC DevOps / SRE / Platform in 2026:

— **Infrastructure-as-code at scale.** Terraform / Pulumi / OpenTofu modules used by 10+ engineering teams. Module versioning. Drift detection. Plan-review discipline. You've owned a Terraform refactor that touched production safely.

— **Kubernetes depth.** Beyond "I know kubectl." Operators / CRDs. StatefulSet patterns. PDB / HPA tuning. Network policies. Service mesh (Istio / Linkerd). You've debugged a CrashLoopBackOff that wasn't the obvious one.

— **Observability stack ownership.** Prometheus + Grafana / Datadog / New Relic at production. SLO definition + error-budget management. Distributed tracing (OpenTelemetry, Jaeger). You've cut MTTD or MTTR materially via dashboard improvements.

— **CI/CD pipelines.** GitHub Actions / GitLab CI / Buildkite at scale. Parallelization. Caching. Reproducible builds. Deploy-to-prod gates. Canary / blue-green / progressive rollouts. You've owned the pipeline through 100+ deploys / week.

— **On-call ownership.** You've held a rotation for a critical system. You've been paged at 3am, found the root cause, written the postmortem, and shipped the fix. The senior-IC bar in 2026 explicitly screens for this story.

— **Capacity + cost.** AWS / GCP / Azure cost analysis as a regular practice. Reservations / Savings Plans. Right-sizing. Spot-instance strategy. You've cut a non-trivial bill (15%+) on a real workload.

— **Security baseline.** IAM policies. Secrets management (Vault / SOPS / cloud-native KMS). Network segmentation. SOC 2 control mapping. You can map a control to an actual technical mechanism.

— **Incident response discipline.** Severity definitions. Communication during outages. Stakeholder updates. Postmortem authorship. The bar at engineering-led shops (Stripe, Cloudflare) is real.

If you've shipped 5-6 of these, you're at the senior-IC bar.

Why now (the 2026 DevOps market)

Three trends shape 2026 hiring:

— **Platform Engineering as the dominant title.** Through 2024 most JDs said "DevOps Engineer" or "SRE." 2026 winning JDs say "Platform Engineer." The work is the same; the framing emphasizes treating internal infra as a product with engineering-customer empathy.

— **Cost discipline is back.** Post-2022 macro shift made cloud bill optimization a senior-IC differentiator again. Candidates who can articulate FinOps work — Reserved Instances, Spot strategy, autoscaling tuning, tiered storage — outpace candidates who only know "deploy and ship."

— **Agentic ops on the horizon.** Coding-agent companies (Cognition, Cursor) and AI-product companies are starting to use agents for incident triage, runbook execution, and capacity-planning analysis. Senior IC SRE who can both shape what agents do AND debug when they go wrong are emerging as the most valuable specialty.

If your background is ops without recent IaC depth, the 2026 senior bar is harder to clear. Spend 4-6 months getting Terraform / Pulumi production work behind you before applying senior.

How to position your resume

SRE resumes get rejected most often on Block D ("trade-off articulation") and Block F ("evidence of incident ownership"). Below-4.0 patterns:

— **Tools-tour resume.** "Used Terraform, Kubernetes, Prometheus, Grafana, Datadog, ArgoCD, Spinnaker." Catalog without scale, problem statement, or trade-off. Senior screeners pattern-match to junior.

— **No SLO / error-budget work.** Mid-IC and below talks about "uptime." Senior-IC talks about defined SLOs, error-budget burn, and how the team prioritizes around it.

— **No incident ownership.** Resume describes operational work without naming an actual outage you debugged + postmortem you authored. The hiring committee fears the candidate will freeze in a real incident.

— **No cost numbers.** Claims of "optimized infra costs" without dollar amounts are noise.

Rewrite to surface:

— **Numbers that imply scale.** "Owned Kubernetes cluster running 800+ pods across 4 regions, supporting $50M ARR product." Specific. — **Trade-offs explicitly named.** "Migrated from Helm to Kustomize for 12 services; gained per-environment overlay clarity at the cost of some templating power. Documented in RFC, accepted across team." — **Failure modes you owned.** "Diagnosed cascading retry storm during downstream provider outage; designed circuit breaker that capped failure-mode amplification across 14 services. Postmortem available on request." — **Cost wins.** "Cut AWS bill 22% over 3 quarters via right-sizing + Reserved Instance strategy + spot-instance migration on stateless workloads. Saved $480k annualized." — **SLO + error-budget work.** "Defined and operated 3 SLOs (latency / availability / saturation) for the auth service; team prioritized infrastructure work using error-budget burn rate as the gating signal."

Lakshya's archetype detector classifies SRE / DevOps / Platform JDs cleanly under "devops-sre" archetype. The keyword tightening done in 2026-04-25 means observability-heavy AI Platform JDs no longer false-match here.

The interview loop, stage by stage

Recruiter screen

20-30 min phone

Signal: Logistics + comp + visa + on-call appetite

Prep: One-line: "I owned X infrastructure at Y scale; on-call participated in Z rotation." Be honest about on-call willingness — this role gates on it.

Hiring manager call

45-60 min

Signal: Can you talk about infra with depth — IaC, K8s, observability, on-call? Have you owned a real incident?

Prep: 2 stories: a perf or cost win you led, an incident you owned the postmortem on. Numbers + before/after.

Coding — practical

60-90 min, often pair-programming

Signal: Production-quality code under pressure. Bash / Go / Python. Error handling, idempotency, retry-safety.

Prep: Practice 4 problem types: (1) write an idempotent Kubernetes operator-style reconcile loop, (2) implement a circuit breaker with sliding window, (3) build a parallelized rollout coordinator with rollback, (4) write a metric-emitter wrapper for an arbitrary HTTP client.

System design — infrastructure

60-90 min

Signal: Can you architect a critical system end-to-end? IaC layout, K8s topology, observability strategy, on-call model, deploy pipeline?

Prep: Pre-draft 4 systems: (1) multi-region payment processor with regulatory data-residency, (2) CI/CD pipeline that deploys 200 services to 3 environments, (3) observability stack for 100-engineer org, (4) Kubernetes platform-as-product team's service catalog.

Incident simulation

60 min

Signal: Live: interviewer plays a simulated incident. You debug under pressure, communicate clearly, write the postmortem outline.

Prep: Practice incident vocabulary aloud: severity definitions, blast radius, customer-facing impact, MTTR, MTTD. Lead with stabilizing the bleed; root-cause comes second.

Behavioral / values

45 min

Signal: On-call burnout management, cross-team partnership, scope cuts, performance-review fairness.

Prep: 4 STAR+R stories — incident postmortem you authored that shipped real fixes, on-call shift that stuck with you, infrastructure debt you advocated cleanup for, mentorship.

Skills inventory

Required

Terraform / Pulumi / OpenTofu — modules, state, plan-review discipline
Kubernetes depth (CRDs, operators, networking, RBAC)
Cloud platform fluency in 1-2 of AWS / GCP / Azure
Linux + bash + scripting (Python or Go)
Observability stack hands-on (Prometheus + Grafana, Datadog, OpenTelemetry)
CI/CD pipeline ownership at scale
On-call rotation experience

Preferred

SLO / error-budget operationalization
FinOps / cost optimization at $1M+ annual scale
Service mesh hands-on (Istio / Linkerd)
Multi-region / disaster-recovery design
Secrets management at scale (Vault / SOPS / KMS)
IaC linting + policy-as-code (OPA, Sentinel)

Bonus

Authored CNCF / open-source operator
Contributor to Terraform / K8s / Prometheus
Production incident at $10M+ exposure you owned
Security clearance (for gov / defense roles)
Postmortem published externally / on engineering blog

Salary bands by region

Region	IC Senior	Staff	Principal
US (SF / NY)	$180-260k	$260-420k	$420-700k+
US (Remote)	$160-230k	$230-360k	$360-560k
India (metro)	₹35-65 LPA	₹65-125 LPA	₹125-240 LPA
Europe (London)	£85-135k	£135-210k	£210-340k
Europe (Berlin)	€80-125k	€125-190k	€190-290k

Sources: levels.fyi 2026Q1, FAANG SRE + scale-out infra · levels.fyi geo-adjusted SRE · levels.fyi India + Razorpay / Cred / Slice / Flipkart SRE · levels.fyi UK + Cloudflare London / Stripe London · kununu + Delivery Hero / N26 SRE

Common rejection patterns + recovery

"Tools-tour resume"

Why: Resume reads as a tech catalog: Terraform, Kubernetes, Prometheus, Grafana, Datadog, ArgoCD, Spinnaker, Vault. No problem statement, scale, or trade-off.

Recovery: Pick 5 bullets per role. Each bullet must contain: the operational problem, the technical choice, a number that implies scale (services, deploys, traffic), and the trade-off. Drop everything else.

"No incident ownership"

Why: Resume describes infra work but no story of an outage you owned the postmortem on. Hiring committee fears candidate will freeze in a real incident.

Recovery: Add 1-2 bullets per role explicitly on incidents owned. Even a sev-2 internal-only outage counts. The narrative pattern is: "diagnosed [root cause] during [outage type]; designed [mechanism] that prevented the regression class."

"No SLO / error-budget work"

Why: Senior+ SRE candidate talks "uptime" generically. Hiring committee in 2026 expects defined SLOs and error-budget operationalization.

Recovery: If you have it, add 1 bullet per role on SLO ownership. If you genuinely don't (smaller-team work without SLO discipline), be honest in interviews — the framing "we operated without formal SLOs but tracked X informally" is more credible than fake SLO claims.

"No cost numbers"

Why: Senior+ candidate at a Fortune-500 with no FinOps work to point to. In 2026 cost discipline is a senior-IC differentiator.

Recovery: Calculate the cost of one workload you operated retroactively. Add 1 bullet quantifying impact even if the work was implicit ("contributed to autoscaling tuning that maintained ARR margin during 3x traffic spike").

FAQ

DevOps / SRE / Platform Engineer — are these the same role?: Overlapping practice, different framings. DevOps is older and broader. SRE is Google's framing — error-budget-focused, often deployed in scale-out infra. Platform Engineering is the 2026 framing — emphasizes internal-engineering-customer empathy. Pick the framing your target company uses; the underlying skill set transfers.
How important is K8s depth in 2026?: Critical at scale-out infra companies. Less critical at smaller shops or those running serverless-first (Vercel, Cloudflare Workers). For senior bar at most companies, you should be able to debug a CrashLoopBackOff that isn't the obvious one.
Cost-optimization (FinOps) — separate role or part of SRE?: In 2026, part of senior SRE. Smaller companies may have a dedicated FinOps function but most senior-IC roles include FinOps responsibility implicitly.
Will agents replace SRE work?: Compresses bottom-40% (basic alerting, runbook execution, log search). Doesn't touch top-60% (incident debugging under pressure, capacity planning, SLO design, security architecture). Senior IC SRE who shape what agents do AND debug when they go wrong are emerging as the most valuable specialty.
How do I show on-call ownership without an SRE title?: Specifics. "Held primary on-call rotation for the auth service; 4-week cycle, 11 incidents owned over 18 months." Generic "I've been on-call" reads as low-confidence.
How does Lakshya help specifically for this archetype?: Three ways: (1) the archetype detector classifies SRE / DevOps / Platform JDs cleanly into "devops-sre" — distinct from ai-platform (which has its own observability work) and backend (which has its own perf work). (2) The CV tailor reframes ops work into operationally-specific language. (3) The story bank captures incident-postmortem stories tagged "devops-sre" — every loop probes them.

Want to know if a real devops-sre role fits you?

Paste any devops-sre JD — get a 7-block A-G evaluation in 30 seconds. Free 3 evals/month.

Start free