What Is DevOps? Culture, Not Just Tools
On this page
The wall between development and operations
In many organizations, developers write code and hand it to an operations team to deploy and run. Developers are rewarded for shipping features; operations for keeping things stable. So releases become rare, large and scary, and every outage starts with an argument about whose fault it was.
DevOps is the response: one team, or closely working teams, share the goal of delivering changes quickly and safely, with the same people caring about both. The term took off around 2009, with John Allspaw and Paul Hammond's "10+ deploys per day" talk at Flickr and Patrick Debois's DevOpsDays conferences.
The CALMS model of DevOps
| Part | Meaning | What it looks like |
|---|---|---|
| Culture | Shared ownership and trust | "You build it, you run it"; blameless postmortems (Day 23) |
| Automation | Machines do repeatable work | CI pipelines, infrastructure as code, automated deploys |
| Lean | Small batches, less waiting | Small pull requests, short-lived branches, fast feedback |
| Measurement | Decisions from data | DORA metrics (Day 26), dashboards, error budgets |
| Sharing | Knowledge flows across teams | Shared runbooks, open postmortems, internal platforms |
Automation is the most visible part, so organizations often start and stop there. The other four are what make it work.
One change, before and after
Follow one small bug fix through both ways of working:
| Step | Dev and ops separated | DevOps |
|---|---|---|
| The fix is written | Tuesday | Tuesday |
| It reaches users | At the monthly release, bundled with 200 other changes | The same day: reviewed, tested by the pipeline, deployed |
| Something goes wrong | Ops sees errors and can't tell which of 200 changes caused them | The team sees errors right after its own small deploy and rolls it back |
| Afterwards | A meeting about whose fault it was | A short review of which test was missing |
Same people, same bug. What changed is how big each release is, and who owns what happens after it ships.
What DevOps changes day to day
- Deploying becomes routine. Instead of a quarterly release weekend, changes go out daily or more, each one small enough to understand and easy to roll back.
- Developers see production. They get alerts for their services, look at dashboards, and join incident calls.
- Operations work becomes code. Servers, networks and pipelines are defined in files, reviewed like application code (Days 16 to 19).
- Failures become lessons. Incidents lead to fixes in the system, not punishment of a person.
A small example of the shift: anyone on the team can deploy, through the same reviewed, automated path, with a manual approval only where it's needed:
name: Deploy service
on:
workflow_dispatch:
inputs:
environment:
description: Target environment
type: choice
options: [staging, production]
required: true
permissions:
contents: read
jobs:
deploy:
runs-on: ubuntu-latest
environment: ${{ inputs.environment }}
steps:
- uses: actions/checkout@v7
- run: ./scripts/deploy.sh "${{ inputs.environment }}"The environment setting lets GitHub require a reviewer for production. No one needs server access, and every deploy is logged. (This and every workflow in the course passes actionlint, a GitHub Actions linter.)
What DevOps isn't
- A job title or a team that sits between dev and ops. A separate "DevOps team" that owns all pipelines often recreates the wall with a new name. Platform teams that build self-service tools for other teams are a healthier version.
- A tool purchase. A CI server doesn't change who gets paged or how failures are treated.
- Only for startups. Large banks, retailers and governments use these practices; the State of DevOps research (DORA) has found the same patterns across industries.
Check yourself
Each big release bundles many changes, so there's more to go wrong, problems are harder to pin down, and rollbacks undo a lot of unrelated work.
Only the automation part. Developers still throw changes over the wall, operations still owns production alone, and feedback from incidents never reaches the people who wrote the code. Tools without shared ownership leave the original wall in place.
Culture, Automation, Lean, Measurement and Sharing. Culture means shared ownership of outcomes; automation removes manual, error-prone steps; lean favors small batches and flow; measurement uses data to improve; sharing spreads knowledge across teams.
The team that writes a service is also on call for it, so they feel the cost of fragile code and invest in monitoring, testing and safe deploys.
It's better seen as a way of working. A "DevOps engineer" who only maintains pipelines for others can become another handoff point.