- Atlas
- Computer Science
- Devops And Sre
Devops And Sre
DevOps and site reliability engineering (SRE) are two overlapping movements that changed how software is built, shipped, and kept running.
11 frameworks, from 1989 to today · Software Engineering · Computer Science
- IT Service Management and ITIL 1989-2010
- Continuous delivery 2000-Present
- Lean software development 2003-Present
- Site reliability engineering 2003-Present
- Blameless postmortem 2005-Present
- Infrastructure as code 2005-Present
- You Build It, You Run It 2006-Present
- DevOps 2009-Present
- Container orchestration 2014-Present
- Observability 2015-Present
- Platform engineering 2018-Present
Overview
DevOps and site reliability engineering (SRE) are two overlapping movements that changed how software is built, shipped, and kept running12. Before them, most organizations split the people who wrote software from the people who operated it: developers handed code over a wall to operations staff, who deployed it and were paged when it broke. That split made large systems slow to change and hard to keep reliable. DevOps and SRE are the names for the long effort to dissolve the wall—to make building and running a service one continuous, measured, automated activity. What is at stake is whether a company can change its software many times a day without falling over, and whether it can know, when something goes wrong, exactly what happened and why.
Operations as a separate craft, and the wall it built
Through the 1990s and 2000s, running production systems was its own discipline. System administrators installed servers, managed networks, and kept databases alive; they wrote runbooks and shell scripts, and they were on call. Developers worked in a separate group with separate goals and often separate budgets. The arrangement had a logic: operations valued stability, developers valued change, and keeping them apart kept each side focused. But it produced a familiar pathology. Deployments were rare, large, and frightening, because each one bundled months of change. When a release failed, the two groups blamed each other, and the incident review asked who had made the mistake rather than what in the system had allowed it.
Two ideas from manufacturing and management began to erode this. The first was lean thinking, derived from the Toyota Production System: the insight that small batches, pulled by demand, expose problems early and reduce waste13. Applied to software, it argued for frequent small releases and for measuring the flow of work rather than the utilization of each group. The second was the recognition, argued influentially by Gene Kim and colleagues in The Phoenix Project (2013), a business novel about an IT department in crisis, that the constraints of IT operations were the constraints of the whole business.
Continuous integration and continuous delivery
The technical precondition for all of this was automation of the path from a developer's change to running software. Continuous integration, popularized in the early 2000s and closely associated with Kent Beck's extreme programming, meant every developer merged to a shared mainline frequently, with an automated build and test run on each merge4. Continuous delivery, set out systematically by Jez Humble and David Farley in Continuous Delivery (2010), extended this: every change that passes automated tests should be deployable to production at the push of a button. The book's central technique was the deployment pipeline—a staged sequence of automated builds, tests, and environment promotions that made release a routine, repeatable act rather than an event.
The point was not speed for its own sake. Small, frequent, automated releases are easier to diagnose when they fail, because each one contains little change. This is the concrete case that made continuous delivery convincing: a team that once shipped quarterly and spent a weekend firefighting can ship daily and roll back in minutes.
Infrastructure as code and the cloud
If releases were to be routine, the environments they landed in had to be reproducible. Traditionally, servers were configured by hand, so no two were quite alike—"configuration drift"—and rebuilding one meant remembering what had been done. Infrastructure as code (IaC) meant describing servers, networks, and services in version-controlled text files that a tool could apply5. Early tools such as CFEngine (from the early 1990s) and Puppet (mid-2000s) managed configuration of existing machines; later, Terraform (2014) and similar tools provisioned cloud resources declaratively. The idea's power is that infrastructure becomes reviewable, testable, and rebuildable like software.
This arrived alongside the public cloud, whose APIs made provisioning programmatic in the first place. Together they let a team create and destroy whole environments on demand, which is what made the pipeline's promise of identical test and production environments achievable.
DevOps: the wall comes down
The term "DevOps" emerged around 2009, associated with a series of "DevOpsDays" conferences that began in Ghent, Belgium, and with practitioners such as Patrick Debois and Andrew Clay Shafer who had been arguing that development and operations had to be one culture. DevOps was never a product or a formal method; it was a banner for a set of practices: shared ownership, automation of the delivery path, measurement, and close collaboration between the groups.
Its most quoted slogan, "you build it, you run it," is attributed to Werner Vogels of Amazon, describing the company's practice of making the team that built a service also responsible for operating it. The claim is that responsibility for production changes design: a team that will be paged at 3 a.m. builds for operability. Amazon's own account of this—small autonomous teams owning services end to end—became a widely copied model.
DevOps also drew on the blameless postmortem, a practice developed in complex-systems safety work and championed in web operations by figures such as John Allspaw. After an incident, the team reconstructs what happened without punishing individuals, on the reasoning that people act sensibly given the information and tools they had, so the fix belongs in the system. The practice spread through the influential "postmortem culture" writing at Google and Etsy and is now standard in the field.
Site reliability engineering
Where DevOps was a cultural movement, SRE was a more formal discipline, named and codified at Google12. The company created the role in the early 2000s, and Ben Treynor Sloss is credited with framing it: SRE is what happens when you ask a software engineer to design an operations team. SREs are engineers who write code to automate operations, and they apply software-engineering standards to reliability itself2.
Its distinctive ideas are quantitative. Service level objectives (SLOs) are targets for measurable reliability—for example, the fraction of requests served successfully—and the error budget is the allowed shortfall. If a service is well within its budget, teams can ship faster; if it exhausts the budget, releases slow until reliability recovers. This turns the old stability-versus-change argument into an explicit, shared number. SRE also insists that toil—repetitive manual operational work—be capped and automated away, and it treats incidents as material for systematic learning. The SRE book published by Google in 2016 made these ideas public and they spread widely.
Containers and orchestration
The next shift was in how software was packaged and scheduled. A container packages an application with its dependencies so it runs identically anywhere6. Containers existed earlier, but Docker, released in 2013, made them easy to build and share. Once many containers ran across many machines, something had to place them, restart failed ones, and route traffic—container orchestration78. Kubernetes, released by Google in 2014 and donated to the Cloud Native Computing Foundation, became the dominant orchestrator. It made the "declarative infrastructure" idea concrete at the application level: you describe the desired state, and the system continuously reconciles reality to it. This is the machinery that lets a small team operate a large fleet.
Observability and platform engineering
As systems became distributed across many services, traditional monitoring—checking known metrics against thresholds—was no longer enough. Observability, a term borrowed from control theory, names the property of being able to answer new questions about a system's internal state from its outputs. In practice it means collecting rich telemetry—logs, metrics, and traces, which follow a single request across services—so that an engineer can investigate an unfamiliar failure without having predicted it in advance9. The concept was popularized in software by Charity Majors and others from the mid-2010s.
Most recently, platform engineering has emerged as a response to a side effect of DevOps: if every product team must own its infrastructure, each reinvents the same pipeline and cluster setup. Platform teams build internal developer platforms—self-service, standardized tooling—so product teams get the benefits of autonomy without duplicating operational expertise10. It is, in a sense, a return of specialization, but with the wall replaced by a product relationship.
Where the field stands
Today the practices descend in a recognizable line: continuous delivery supplies the pipeline, infrastructure as code and Kubernetes supply the reproducible substrate, SRE supplies the reliability targets and incident discipline, and observability supplies the means to understand what is happening. The open questions are real. Error budgets and SLOs work cleanly for request-serving services but fit awkwardly for batch systems and data pipelines. Platform engineering risks recreating a wall if platforms become gatekeepers rather than enablers. And the cost and complexity of distributed systems—many small services, many tools—has prompted a counter-current toward simpler architectures. The field's central tension, between moving fast and staying up, has not been resolved; it has been made measurable.
References
- DevOps (introduction, Toyota Production System, Lean Thinking, Kaizen, Site Reliability Engineering), Wikipedia
- Site reliability engineering, Wikipedia
- Kanban (development), Wikipedia
- Continuous integration (introduction, History), Wikipedia
- Infrastructure as code, Wikipedia
- Docker (software), Wikipedia
- Orchestration (computing), Wikipedia
- Kubernetes, Wikipedia
- Observability (software), Wikipedia
- Platform engineering, Wikipedia
The frameworks of Devops And Sre
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1989-2010
IT Service Management and ITIL
How should IT services be managed and delivered?
- 2000-Present
- 2003-Present
- 2003-Present
Site reliability engineering
How do we make reliability an engineering discipline?
- 2005-Present
- 2005-Present
- 2006-Present
- 2009-Present
- 2014-Present
Container orchestration
How do we schedule many containers across machines?
- 2015-Present
- 2018-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
DevOps influenced by Continuous delivery
Continuous delivery supplied DevOps with its core technical practice: the automated deployment pipeline that makes frequent, routine releases possible. DevOps adopted the pipeline as the concrete mechanism for dissolving the dev/ops handoff.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Container orchestration influenced by Infrastructure as code
Kubernetes applied the declarative infrastructure-as-code idea at the application level: users describe desired state in configuration and the system reconciles reality to it. The reconciliation-loop model came directly from IaC tools such as Puppet and Terraform.
Carried by Kubernetes (2014).
DevOps influenced by You Build It, You Run It
Werner Vogels' formulation that the team that builds a service also runs it became DevOps' most quoted slogan and a defining practice of shared ownership. Amazon's small autonomous service teams were the model DevOps practitioners copied.
Carried by Werner Vogels.
Site reliability engineering reacted against IT Service Management and ITIL
SRE was framed at Google as an alternative to traditional IT operations and ITIL-style service management, replacing ticket-driven, process-heavy operations with software engineering and quantitative reliability targets. The SRE role was defined in explicit contrast to the operations model ITIL codified.
Carried by Ben Treynor Sloss.
DevOps reacted against IT Service Management and ITIL
DevOps emerged partly as a rejection of the ITIL-style separation of development and operations, with its change-management gates and handoffs. The DevOpsDays movement defined itself against the wall that ITSM processes reinforced.
Carried by Patrick Debois; Andrew Clay Shafer.
Infrastructure as code influenced by Continuous delivery
Continuous delivery's demand for identical, reproducible test and production environments drove the adoption of infrastructure as code, so that environments could be rebuilt from version-controlled definitions as part of the pipeline.
Carried by Jez Humble; David Farley.
DevOps influenced by Lean software development
Lean software development's small-batch, flow-based thinking, drawn from the Toyota Production System, shaped DevOps' argument for frequent small releases and measuring flow rather than group utilization. Gene Kim and colleagues carried lean ideas into the DevOps narrative.
Carried by Mary Poppendieck; Gene Kim; The Phoenix Project (2013).
Blameless postmortem influenced by Site reliability engineering
SRE's treatment of incidents as material for systematic learning, and its insistence on blameless reconstruction of what happened, reinforced and spread the blameless postmortem practice. Google's postmortem culture writing carried the practice into the wider field.
Carried by Google SRE; Site Reliability Engineering (2016).
DevOps rival of Site reliability engineering
SRE and DevOps arose as overlapping but competing answers to the same problem of unifying development and operations, with SRE offering a formal engineering discipline and DevOps a cultural movement. They are contemporaries that competed for the field's allegiance rather than one descending from the other.
Carried by Ben Treynor Sloss; Patrick Debois.
DevOps influenced by Blameless postmortem
The blameless postmortem, championed in web operations by John Allspaw and others, became a standard DevOps practice for learning from incidents without punishing individuals. DevOps adopted it as part of its shared-ownership culture.
Carried by John Allspaw; Etsy.
Platform engineering grew out of DevOps
Platform engineering arose as a response to a side effect of DevOps: when every product team owns its infrastructure, each reinvents the same pipeline and cluster setup. Platform teams reintroduce specialization through a self-service product relationship rather than the old wall.
Observability influenced by Container orchestration
The spread of container orchestration distributed systems across many services, which made traditional threshold monitoring insufficient and created the need for observability. Tracing a single request across services became necessary because Kubernetes-style deployments fragmented execution.
Carried by Charity Majors.
Platform engineering influenced by Container orchestration
Kubernetes and container orchestration created the cluster-setup burden that platform engineering set out to standardize and hide behind self-service internal platforms. Platform teams build on orchestration as their substrate.
Beyond the field
Where Devops And Sre's ideas came from in other fields, and what they led to there: the strongest 12 of 28 links.
Continuous delivery influenced DevOps in Systems Lifecycle
Continuous delivery, articulated by Humble and Farley in 2010 and rooted in earlier CI practice, supplied DevOps with its central technical mechanism: the automated deployment pipeline. DevOps adopted continuous delivery as the concrete practice realizing its development-operations integration.
Carried by Jez Humble; Continuous Delivery (2010).
Continuous delivery influenced DevOps in Software Process Models
Continuous delivery supplied DevOps with its central technique of automated, always-deployable pipelines and deployment automation. DevOps practitioners adopted continuous delivery as the mechanism for bridging development and operations.
Carried by Jez Humble.
Continuous delivery grew out of Continuous Integration in Systems Integration
Continuous delivery grew directly out of continuous integration practice: the Humble and Farley book extended CI's automated build-and-test loop to deployment and release, making every build a release candidate.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Lean software development influenced by Lean manufacturing in Manufacturing Engineering
Lean software development, set out by Poppendieck and Poppendieck, explicitly transferred lean manufacturing's principles, especially the Toyota Production System's waste elimination, flow and pull, to software work.
Carried by Mary Poppendieck; Tom Poppendieck; Lean Software Development (2003).
Site reliability engineering influenced by Reliability Engineering in Reliability Fault Tolerance
Site reliability engineering took reliability engineering's core apparatus, especially service level objectives, error budgets and failure-rate measurement, and applied it to large-scale software services.
Carried by Benjamin Treynor Sloss.
DevOps influenced by Continuous Integration and Continuous Delivery in Systems Lifecycle
Continuous integration and continuous delivery provided the automation pipeline, deployment tooling and 'delivery as a repeatable process' concept that DevOps adopted as its technical core. DevOps extended CI/CD from the build-and-release stage to the whole development-operations lifecycle.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
DevOps influenced by Agile and Continuous Delivery in Software Evolution
Agile and continuous delivery supplied DevOps with its core practices: cross-functional teams, automated build-test-deploy pipelines and short release cycles. The DevOps movement of 2009 grew directly out of the agile and continuous-delivery community's push to extend those practices into operations.
Carried by Jez Humble; Continuous Delivery (2010); Patrick Debois.
Container orchestration influenced by Container-based isolation in Operating Systems
Container-based isolation, especially Linux containers and Docker (2013), provided the packaging and isolation primitive that container orchestration systems such as Kubernetes (2014) were built to schedule and manage. Orchestration is unthinkable without the container as its unit of deployment.
Carried by Docker (2013); Linux containers.
IT Service Management and ITIL influenced by Quality engineering and statistical process control in Mechanical Engineering
ITIL's service support and delivery processes drew on quality-management thinking, including Deming's and Juran's statistical quality control and continuous-improvement ideas, which shaped its emphasis on measurable process control and improvement.
Carried by W. Edwards Deming; Joseph Juran.
Continuous delivery influenced DevOps in Software Evolution
DevOps grew out of continuous delivery practice: the automated build, test and deployment pipeline is the technical core that DevOps extends to operations and culture. Continuous delivery supplied the deployment automation that DevOps presupposes.
Carried by Jez Humble; Continuous Delivery (2010).
Continuous delivery influenced by Extreme Programming in Software Process Models
Extreme Programming's practices, especially continuous integration, small releases and test-first development, were taken up by continuous delivery's makers as the development-side practices the deployment pipeline automates.
Carried by Kent Beck.
Lean software development influenced by Agile Software Development in Software Engineering
Lean software development was framed as an extension of agile thinking, taking the Agile Manifesto's values and adding lean manufacturing's flow and waste-reduction concepts.
Carried by Mary Poppendieck.

Devops And Sre is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Devops And SreRelated fields
Fields its ideas are linked to
- Software Evolution 5 links
- Software Process Models 4 links
- Software Engineering 3 links
- Systems Lifecycle 3 links
- Patient Safety 2 links
- Systems Integration 2 links
- Venture Creation 1 link
- Digital Strategy 1 link
- Innovation Management 1 link
- Manufacturing Engineering 1 link
- Mechanical Engineering 1 link
- Cloud Computing 1 link