What is DevOps? Practices, metrics and tools
DevOps is a way of delivering software in which the people who build a system and the people who run it share responsibility for getting changes to users quickly and safely. It is not a tool or a job title. In practice it shows up as automation (builds, tests, deployments, infrastructure), fast feedback (from tests, monitoring and users), and small, frequent, low-risk changes. This page explains the practices, how to measure whether they are working, and where each tool in this section fits. For the reading path through the section, start at the DevOps overview.
Topics on this page
Section titled “Topics on this page”| Topic | What it answers |
|---|---|
| The problem DevOps solves | Why separate development and operations slowed delivery down. |
| Core practices | Continuous integration, continuous delivery, infrastructure as code, configuration management, database delivery and observability. |
| Measuring delivery performance | DORA’s five software delivery metrics and how to use them. |
| Tool landscape | The tools covered on this site, what each is for, and current versions. |
| A delivery pipeline end to end | How the tools combine for one change to the OrdersPortal application. |
The problem DevOps solves
Section titled “The problem DevOps solves”In the traditional model, developers wrote code and handed a release to an operations team that deployed and ran it. Each side optimized for its own goal: developers for shipping features, operations for stability. Releases became large and infrequent because each one was risky, and because they were large, they were even riskier. Environments were configured by hand and drifted apart, so “it worked in test” said little about production. When something broke, the people who could fix the code were not the people who saw the failure.
DevOps attacks that loop from several directions. Automating builds, tests and deployments makes releasing cheap, so teams release smaller changes more often. Defining environments as code makes them reproducible, so test and production behave alike. Shared ownership and shared metrics mean the team that changes a system also watches how it behaves in production. The result, which DORA’s research has repeatedly found, is that speed and stability are not a trade-off: teams that deliver more often also tend to fail less.
Pitfalls:
- Renaming the operations team “DevOps team”. If one team still throws releases over the wall to another, nothing has changed except the name.
- Buying tools first. A pipeline that automates a bad process makes it fail faster. Start with the flow of work, then automate it.
Core practices
Section titled “Core practices”Continuous integration (CI). Developers merge small changes into a shared main branch frequently, and every change is built and tested automatically. Breakages are found within minutes, while the change is still fresh. CI needs a fast, reliable test suite and the discipline to fix a broken main branch immediately. See GitLab CI/CD pipelines and TeamCity.
Continuous delivery and deployment (CD). Every change that passes the pipeline is releasable, and deploying it is an automated, repeatable step. Continuous delivery keeps a human approval before production; continuous deployment releases automatically. Techniques such as feature flags, blue-green and canary releases separate deploying code from releasing features to users.
Infrastructure as code (IaC). Servers, networks, clusters and cloud services are declared in version-controlled files and created by tools, so environments are reviewed, reproducible and recoverable. See Terraform.
Configuration management. The software and settings inside machines (packages, services, files, users) are described as code and applied idempotently, so every server of a kind is the same. See Ansible. Containers move much of this into the image build; see Docker.
Database delivery. Schema changes are versioned and applied by the pipeline, in order, once per environment, with tested rollbacks, instead of being run by hand. See Liquibase.
Observability and feedback. Logs, metrics and traces show how each release behaves in production, and alerts route problems to the team that owns the service. Without this feedback, faster delivery only means faster unnoticed failures.
Pitfalls:
- CI without trunk discipline. Long-lived branches merged once a month are not continuous integration, whatever the pipeline is called.
- Automating deployment but not rollback. Every deployment process needs an equally practiced way back.
Measuring delivery performance
Section titled “Measuring delivery performance”DORA (DevOps Research and Assessment), a long-running research program on software delivery, defines software delivery performance with five metrics in two groups. The original “four keys” became five, and “mean time to restore” was replaced by failed deployment recovery time.
| Group | Metric | Definition (from dora.dev) |
|---|---|---|
| Throughput | Change lead time | Time from a change being committed to version control to it being deployed in production. |
| Throughput | Deployment frequency | Number of deployments over a period, or the time between deployments. |
| Throughput | Failed deployment recovery time | Time to recover from a deployment that fails and needs immediate intervention. |
| Instability | Change fail rate | Share of deployments that need immediate intervention, such as a rollback or hotfix. |
| Instability | Deployment rework rate | Share of deployments that are unplanned and happen because of a production incident. |
Use them per application or service, track trends over time, and look at all five together. DORA’s own guidance warns against turning a metric into a target, comparing unlike systems, and measuring at the expense of improving. A common lever for all five is working in smaller batches: smaller changes are easier to review, test, deploy and roll back.
Pitfalls:
- Deployment frequency as a quota. Teams split deployments artificially and nothing improves.
- Measuring teams against each other. The metrics are for a team to improve its own delivery, not for ranking.
Tool landscape
Section titled “Tool landscape”This site covers the tools below. DevOps itself has no versions, but the tools do; the versions are the latest releases checked in November 2026 from each project’s releases or documentation source.
| Tool | Category | Use it for | Current release (Nov 2026) |
|---|---|---|---|
| GitLab CI/CD | CI/CD built into GitLab | Pipelines defined in .gitlab-ci.yml next to the code |
GitLab 19.x |
| TeamCity | CI/CD server | Large, multi-platform builds, build chains, Kotlin DSL | Documentation for 2026.3 |
| Harness | Delivery platform | CI/CD, feature flags and related modules as a service | See the Harness page |
| Ansible | Configuration management | Agentless configuration and deployment over SSH and WinRM | ansible-core 2.22, Ansible 15.0 |
| Liquibase | Database change management | Versioned schema changes and rollbacks | Liquibase 5.0.4 |
| Terraform | Infrastructure as code | Declarative cloud and platform resources | Terraform 1.17.2 |
| Docker | Containers | Packaging and running applications as images | Docker CLI 29.x, Compose 5.x |
| Kubernetes | Container orchestration | Running containers across a cluster | Kubernetes 1.37, Helm 4.3 |
Most teams need one tool per row they actually use, not one of everything. A team on GitLab usually starts with GitLab CI/CD; a team with heavy Windows and JVM builds may prefer TeamCity. Terraform and Ansible are complementary: Terraform creates the machines and services, Ansible configures what runs inside machines. Containers and Kubernetes reduce how much server configuration you need, but not the need for IaC.
A delivery pipeline end to end
Section titled “A delivery pipeline end to end”Here is one change to the invented OrdersPortal application, an ASP.NET Core API with a PostgreSQL database, moving through the tools in this section:
- A developer opens a merge request that adds an order status column and the API code that uses it.
- The pipeline builds and tests the API, builds a Docker image tagged with the commit SHA, runs
liquibase validateand attachesupdate-sqloutput for review, and runsterraform planif infrastructure files changed. - After review and merge, the pipeline applies the Liquibase changeset to staging (the column is added in a backward-compatible way), deploys the image to staging, and runs smoke tests.
- A manual, protected job promotes the same image and changeset to production: Liquibase first, then a rolling deployment (Kubernetes or Ansible with
serial), each step gated on health checks. - Dashboards and alerts watch error rates and latency for the new version; if they degrade, the pipeline’s rollback job redeploys the previous image, and the database change needs no rollback because it was additive.
Every step is code in the repository, every run leaves a log, and the same process runs for every change. That is the practical definition of DevOps this section teaches.
Interview questions
Section titled “Interview questions”What is the difference between continuous delivery and continuous deployment? In continuous delivery every change that passes the pipeline is releasable, but a person decides when to deploy to production. In continuous deployment every passing change is deployed to production automatically.
Which metrics would you use to show that delivery is improving? DORA’s five: change lead time, deployment frequency and failed deployment recovery time for throughput, and change fail rate and deployment rework rate for instability, tracked per service over time and read together.
Why do smaller batches improve both speed and stability? Small changes are faster to review and test, easier to reason about when something fails, and cheaper to roll back, so teams can deploy more often while each deployment carries less risk.
Senior scenario: OrdersPortal releases monthly with a weekend outage, and half of the releases need a hotfix. Where do you start? Measure the current five metrics to have a baseline. Then shrink batch size: trunk-based development with CI on every merge, an automated pipeline that builds one image per commit and promotes it unchanged, database changes through Liquibase using expand and contract so deployments need no outage, and IaC so staging matches production. Add health-checked rolling deployments with automated rollback and production monitoring per release, then move from monthly to weekly to on-demand releases as change fail rate drops.
Related pages
Section titled “Related pages”- DevOps overview: the reading path for this section.
- GitLab CI/CD pipelines and TeamCity
- Ansible automation and Liquibase database migrations
- Terraform, Docker and Kubernetes