What's actually the difference between DevOps, SRE, and Platform Engineering — as practices, not just job titles — and how would you explain it to someone outside the team?

DevOps is a cultural/organizational philosophy — breaking down the wall between building software and running it, so the people who write code also own its operational outcomes. SRE (Site Reliability Engineering) is one concrete, opinionated implementation of that philosophy, treating operations as a software engineering problem with specific mechanisms like SLOs and error budgets. Platform Engineering is a further evolution that builds internal self-service tooling so product teams can practice DevOps/SRE principles themselves without needing to become infrastructure experts.

These three overlap enough in daily practice that the confusion is legitimate, but they answer different questions:

DevOps is fundamentally a cultural stance, not a specific toolset or job description: the traditional split between a "dev" team that builds software and an "ops" team that runs it creates misaligned incentives (dev is rewarded for shipping features, ops is rewarded for stability, and the two goals fight each other). DevOps says the same people (or at least tightly collaborating people) should be responsible for both — "you build it, you run it" — using automation (CI/CD, infrastructure as code) to make that practical at scale. It's intentionally broad and doesn't prescribe exactly how to implement it.

SRE is Google's specific answer to "okay, concretely, how do you implement that." It applies software engineering rigor to operations problems: instead of an operations team that responds to whatever breaks, SRE defines reliability numerically (SLIs/SLOs), budgets an explicit, spendable amount of acceptable unreliability (error budgets), and uses that budget as the actual mechanism deciding the trade-off between shipping features and investing in stability — including capping the time SREs spend on manual "toil" versus engineering work. SRE is DevOps with specific, prescriptive mechanisms attached.

Platform Engineering is a response to a real failure mode both of the above can fall into at scale: if every product team has to independently practice DevOps/SRE — build their own CI/CD, provision their own infrastructure, understand Kubernetes deeply — that's enormous duplicated effort and inconsistent quality across teams. Platform engineering centralizes that expertise into an internal platform team that builds paved-road, self-service tooling (internal developer platforms, golden-path templates, automated provisioning) so product teams get the benefits of good DevOps/SRE practice without each of them needing to independently reinvent it. It's DevOps and SRE principles, delivered as a product to internal customers rather than practiced ad hoc by every team.

A useful way to state the relationship for someone unfamiliar with all three: DevOps is the philosophy, SRE is one rigorous implementation of that philosophy focused on reliability engineering, and Platform Engineering is the infrastructure that makes practicing either of them scalable across many teams instead of requiring every team to be expert in it.

• If you joined a company with none of these formalized, which would you introduce first, and why?
• How would you tell whether a "Platform Engineering" team at a company is genuinely building self-service tooling versus just being ops under a new name?
• Can a small startup meaningfully practice SRE, or does the error-budget/SLO machinery only make sense past a certain scale?

• DevOps is a cultural philosophy about aligning build and run responsibilities; it doesn't prescribe specific mechanisms.
• SRE is a specific, measurable implementation of DevOps principles, built around SLOs, error budgets, and treating ops as a software engineering discipline.
• Platform Engineering builds internal self-service tooling so many product teams can benefit from DevOps/SRE practices without each team independently mastering the underlying infrastructure.
• In practice at most companies these overlap heavily and the exact title someone has says less than what they're actually doing day to day.

• Google SRE Book: Introduction
• Google Cloud: DevOps vs SRE
• Platform Engineering: What is an Internal Developer Platform?