Catalog My learning Blog
CI/CD and DevOps Tutorial: Build a Delivery Pipeline · Phase 1 · Lesson 1 · 3 min read

What Is DevOps? Culture, Not Just Tools

On this page
  1. The wall between development and operations
  2. The CALMS model of DevOps
  3. One change, before and after
  4. What DevOps changes day to day
  5. What DevOps isn't
  6. Check yourself

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

PartMeaningWhat it looks like
CultureShared ownership and trust"You build it, you run it"; blameless postmortems (Day 23)
AutomationMachines do repeatable workCI pipelines, infrastructure as code, automated deploys
LeanSmall batches, less waitingSmall pull requests, short-lived branches, fast feedback
MeasurementDecisions from dataDORA metrics (Day 26), dashboards, error budgets
SharingKnowledge flows across teamsShared 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.

DevOps as a loop of plan, build, test, release, deploy, operate and monitor, owned by one team rather than handed over a wall.
DevOps as a loop of plan, build, test, release, deploy, operate and monitor, owned by one team rather than handed over a wall.

One change, before and after

Follow one small bug fix through both ways of working:

StepDev and ops separatedDevOps
The fix is writtenTuesdayTuesday
It reaches usersAt the monthly release, bundled with 200 other changesThe same day: reviewed, tested by the pipeline, deployed
Something goes wrongOps sees errors and can't tell which of 200 changes caused themThe team sees errors right after its own small deploy and rolls it back
AfterwardsA meeting about whose fault it wasA 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:

YAML
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.