DevOps, CI/CD & Containers

What Is DevOps? Culture, Practices and the Delivery Pipeline

Beginner9 min readReviewed by on Updated

DevOps is the practice of getting software from a developer's editor to production quickly, safely and repeatedly by removing the wall between development and operations. After reading this guide you will understand why that wall exists, what the CALMS pillars and the DORA metrics actually measure, which practices matter first, and how to recognise a DevOps transformation that is going wrong.

What you will learn

  • Explain the conflict between development and operations that DevOps sets out to resolve
  • Describe the CALMS pillars and the four DORA delivery metrics
  • Name the core practices — version control, CI/CD, infrastructure as code, monitoring — and how they fit together
  • Compare the common ways of organising teams for DevOps and the failure modes of each
  • Plan a realistic first step for a team that wants to deliver more often

Every organisation that writes software has two forces pulling in opposite directions. Development is rewarded for change: new features, faster time to market, experiments. Operations is rewarded for stability: uptime, predictable capacity, no surprises on a Friday evening. When those two groups sit in different departments with different managers and different goals, the natural result is a hand-off — a release package thrown over a wall with a deployment document attached — and a slow, blame-heavy release process that nobody enjoys. DevOps is the set of ideas and practices that grew up to remove that wall. This guide explains what the term means beyond marketing, what actually changes in a team that practises it, and how to begin.

The problem DevOps solves

Picture the traditional cycle. A project team builds a release for several months. Testing happens at the end. A change-advisory board meets to approve the deployment. Operations installs it on servers they configured by hand a year ago, following a Word document, at 2 a.m. on a Saturday. Something breaks that never broke in the test environment, because the test environment is not the same as production. Developers are called, operations is blamed, and the next release is scheduled even further out to "reduce risk".

The instinct to release less often is precisely backwards. A release that contains six months of changes is enormous, hard to test and almost impossible to roll back. A release that contains one day of changes is small, easy to understand, and if it fails, the cause is obvious. Small batches are the single most important idea underneath DevOps: reduce the size of each change, and the risk, the fear and the ceremony around releasing shrink with it.

Two other pressures made the old model untenable. Product teams that adopted agile methods started producing potentially shippable software every two weeks, then found it waiting months for a release slot. And the arrival of cloud APIs meant that servers, networks and load balancers could be created by a script — infrastructure had become software, and software needs software engineering practices.

CALMS: the five pillars

A widely used way to summarise the movement is the acronym CALMS — Culture, Automation, Lean, Measurement, Sharing. It is useful precisely because only one of the five letters is about tools.

Culture. Development and operations share responsibility for the service in production. "You build it, you run it" is the extreme version: the team that writes a service is on call for it. The milder version is that operational concerns — deployability, monitoring, capacity, security patches — are part of the definition of done, not somebody else's problem afterwards. Incidents are investigated with blameless post-mortems that look for the systemic cause rather than the person who typed the command.

Automation. Anything done more than twice is scripted: building, testing, packaging, provisioning servers, deploying, rolling back. Automation is not only about saving time. A script is repeatable, reviewable and testable in a way that a runbook followed by a tired human is not, and it makes environments identical instead of merely similar.

Lean. Borrowed from manufacturing: work in small batches, limit work in progress, make the flow of work visible, and remove waste — waiting for approvals, hand-offs between teams, rework caused by defects found late. Value-stream mapping, where you draw every step from idea to production and measure how long work waits at each one, is the classic exercise and usually reveals that most of the lead time is queueing, not working.

Measurement. You cannot improve what you do not measure. That means technical metrics (build time, deployment frequency, error rates, latency), and also business ones (sign-ups, orders, revenue per hour) so that a bad deployment shows up as a business problem within minutes. Metrics must be visible to everyone, not locked in an operations dashboard.

Sharing. Knowledge, tools and code cross team boundaries. Developers can read production configuration and operations engineers can open pull requests against application code. Post-mortem reports are published internally. Reusable pipelines, base images and Terraform modules are maintained as shared products.

The core practices

The pillars are principles; these are what a team actually does.

Everything in version control

Application code obviously, but also build scripts, infrastructure definitions, server configuration, database migrations, dashboards and alert rules. If it is not in Git, it cannot be reviewed, reproduced or rolled back. See the Git fundamentals guide for the mechanics.

Continuous integration

Every developer merges into the main branch at least daily, every merge triggers an automated build that compiles the code and runs the test suite, and a broken build is fixed before anything else. The point is to find integration problems within minutes of creating them instead of weeks later. Continuous integration has its own guide.

Continuous delivery

The build produces a versioned, immutable artifact — a jar, a container image — that moves through environments unchanged. Deployment is a scripted, push-button (or fully automatic) step, and the pipeline proves that every commit is releasable. Continuous deployment goes one further and releases every green build to production without a human decision. The delivery pipeline guide covers the stages, strategies and database migrations involved.

Infrastructure as code

Servers, networks, DNS records, cluster definitions and their configuration are declared in files, applied by tools such as Terraform or OpenTofu and Ansible, and reviewed like any other change. The old habit of logging into a server and editing a file by hand — which produces "snowflake" machines nobody can rebuild — is replaced by rebuilding from source. The infrastructure as code guide goes into the tools.

Containers and orchestration

Docker images package the application with its runtime so that development, CI and production run the same bits. Kubernetes schedules those containers across a cluster, restarts them when they fail and rolls out new versions gradually. Containers are not mandatory for DevOps, but they make the "same artifact everywhere" promise cheap to keep.

Monitoring, logging and feedback

Metrics (Prometheus, Grafana), centralised logs (the Elastic stack, Loki) and distributed tracing close the loop: the team that deployed a change sees its effect on error rates and latency within minutes. Alerts page the people who can fix the problem, and dashboards are designed around user-facing symptoms rather than CPU graphs.

Measuring delivery: the DORA metrics

The DevOps Research and Assessment (DORA) programme spent years surveying thousands of organisations and reduced delivery performance to four numbers.

MetricQuestion it answersElite performers (typical)
Deployment frequencyHow often does code reach production?Multiple times per day
Lead time for changesHow long from commit to running in production?Less than a day
Change failure rateWhat share of deployments cause an incident or rollback?Low single digits to around 15 %
Time to restore serviceHow long does recovery from a failure take?Less than an hour

The first two measure throughput, the last two measure stability. The most important finding from the research is that they move together: teams that deploy more often also fail less and recover faster, because small changes are safer and automated pipelines make fixes as quick to ship as features. Choosing between "fast" and "reliable" is a false dilemma once the engineering practices are in place.

Use the metrics as a diagnostic, not a target to game. A team that deploys ten times a day with a 40 % failure rate has a testing problem; a team with a one-hour lead time and quarterly releases has an approval-process problem.

Organising teams

How you draw the org chart matters as much as which tools you buy. Several arrangements recur.

Dev and Ops silos, plus a "DevOps team" in between. The most common anti-pattern. A new team owns the pipelines and the Kubernetes cluster, developers file tickets to get things deployed, and there are now three silos instead of two.

Fully integrated product teams. Each cross-functional team owns a service end to end: code, pipeline, infrastructure, on-call. This is the purest model and works well for organisations with strong engineers and a limited number of services, but it duplicates platform work across teams.

Platform team plus stream-aligned teams. Product teams own their services; an internal platform team provides the paved road — a CI/CD service, base images, a cluster, observability, secret storage — as a product with documentation and an API. Product teams consume the platform in self-service mode instead of raising tickets. For most organisations of any size this is the arrangement that scales.

Ops embedded temporarily. An operations engineer joins a product team for a few months to build deployment automation and train the team, then moves on. Useful as a transition, harmful if it becomes permanent because the knowledge leaves with the engineer.

Whatever the structure, the test is simple: can a developer get a change to production without waiting on another team? If the answer is a ticket queue, the transformation has not happened yet.

Common mistakes

  • Tools first. Buying Jenkins, Docker and Kubernetes and expecting culture to follow. The tools amplify whatever process exists; automating a broken process makes it fail faster.
  • Renaming the operations team. Changing "Ops" to "DevOps" on the org chart without changing responsibilities, incentives or the deployment process.
  • Measuring activity instead of outcomes. Counting pipelines built or containers running instead of lead time and failure rate.
  • Skipping the boring foundations. Trying canary releases before the test suite is trustworthy, or Kubernetes before the application can be configured through environment variables. The twelve-factor principles are a good checklist for application readiness.
  • Ignoring security until the end. Security reviews as a final gate recreate the hand-off problem. Dependency scanning, image scanning and static analysis belong in the pipeline from the first week, which is what the term DevSecOps refers to.
  • Big-bang transformation. Announcing that every team will be "DevOps by Q3". Transformations that work start with one team, one service, one pipeline, and copy what succeeded.

Getting started

  1. Map the current path to production

    Write down every step from a merged commit to a running deployment, who does it, and how long the work waits at each stage. The waiting time, not the working time, is usually the surprise.
  2. Put everything under version control and automate the build

    One command that produces the deployable artifact from a clean checkout, run on a CI server on every push. Nothing else is possible without this.
  3. Make the test suite trustworthy

    A pipeline that is red half the time for reasons nobody investigates is ignored. Delete or fix flaky tests, keep the build under ten minutes, and treat a red main branch as the team's top priority.
  4. Script the deployment

    Replace the runbook with a script or pipeline stage that deploys to a test environment identical in shape to production. Then reuse the same script for production.
  5. Add monitoring the team actually looks at

    A dashboard of request rate, error rate and latency per service, with an alert on the error rate, gives the feedback loop that makes small frequent releases safe.
  6. Increase the release frequency deliberately

    Move from monthly to fortnightly to weekly. Each step exposes the next bottleneck — manual approvals, database migrations, environment drift — which becomes the next thing to automate.

Key takeaways

  • DevOps addresses the structural conflict between teams rewarded for change and teams rewarded for stability by giving them shared ownership of the running service.
  • Small batches are the core idea: smaller changes are easier to test, deploy, understand and roll back, so releasing more often reduces risk rather than adding to it.
  • CALMS — culture, automation, lean, measurement, sharing — describes the movement; only automation is about tooling.
  • The practices are concrete: everything in version control, continuous integration, a delivery pipeline producing immutable artifacts, infrastructure as code, and monitoring that feeds back to the team.
  • The four DORA metrics measure throughput and stability together, and high performers improve both at once.
  • Structure teams so that a developer can reach production without a ticket queue; a "DevOps team" between Dev and Ops usually becomes a third silo.
  • Start with one team and the boring foundations — repeatable build, trustworthy tests, scripted deployment — and increase release frequency step by step.

Sources and further reading

Frequently asked questions

Is DevOps a job title?
Many companies advertise 'DevOps engineer' roles, and in practice they usually mean someone who builds pipelines, automates infrastructure and runs platforms. But DevOps as an idea is about how development and operations work together, not a separate team that owns automation. A 'DevOps team' sitting between Dev and Ops can become a third silo, which is the opposite of the intent.
What is the difference between DevOps and Agile?
Agile methods shorten the loop between a request and working software, but most of them stop at 'done' meaning 'ready to be deployed'. DevOps extends the same short-feedback thinking through deployment, operation and monitoring, so that 'done' means 'running in production and observed'. The two are complementary; a Scrum team that ships to production once a quarter is only agile on paper.
Do I need Kubernetes or the cloud to do DevOps?
No. The practices — everything in version control, automated builds and tests, scripted deployments, monitoring and blameless post-mortems — work on a pair of physical servers. Containers and cloud APIs make environments cheaper to reproduce and automate, which lowers the cost of the practices, but adopting the tools without the practices delivers very little.
How do I measure whether DevOps is working?
Use the four DORA metrics: deployment frequency, lead time for changes, change failure rate and time to restore service. Together they capture both speed and stability. Elite performers score well on all four, which shows that speed and reliability are not a trade-off when the engineering practices are in place.