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

still a working view ended · each leads to its entry below

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

  1. DevOps (introduction, Toyota Production System, Lean Thinking, Kaizen, Site Reliability Engineering), Wikipedia
  2. Site reliability engineering, Wikipedia
  3. Kanban (development), Wikipedia
  4. Continuous integration (introduction, History), Wikipedia
  5. Infrastructure as code, Wikipedia
  6. Docker (software), Wikipedia
  7. Orchestration (computing), Wikipedia
  8. Kubernetes, Wikipedia
  9. Observability (software), Wikipedia
  10. 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.

  1. 1989-2010

    IT Service Management and ITIL

    How should IT services be managed and delivered?

    Fly to its tower in Nousfarer

  2. 2000-Present

    Continuous delivery

    How can every change be made deployable?

    Fly to its tower in Nousfarer

  3. 2003-Present

    Lean software development

    How do we remove waste from software work?

    Fly to its tower in Nousfarer

  4. 2003-Present

    Site reliability engineering

    How do we make reliability an engineering discipline?

    Fly to its tower in Nousfarer

  5. 2005-Present

    Blameless postmortem

    How do we learn from failure without blame?

    Fly to its tower in Nousfarer

  6. 2005-Present

    Infrastructure as code

    How do we make environments reproducible?

    Fly to its tower in Nousfarer

  7. 2006-Present
  8. 2009-Present

    DevOps

    How do we unify building and running software?

    Fly to its tower in Nousfarer

  9. 2014-Present

    Container orchestration

    How do we schedule many containers across machines?

    Fly to its tower in Nousfarer

  10. 2015-Present

    Observability

    How can we answer new questions about a system?

    Fly to its tower in Nousfarer

  11. 2018-Present

    Platform engineering

    How do we give teams self-service infrastructure?

    Fly to its tower in Nousfarer

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.

IT Service Management and ITILContinuous deliveryLean software developmentSite reliability engineeringBlameless postmortemInfrastructure as codeYou Build It, You Run ItDevOpsContainer orchestrationObservabilityPlatform engineering

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Sre

Related fields

Fields its ideas are linked to

More in Software Engineering

See where Devops And Sre sits on the Map of Human Knowledge