Summary for leaders: DevOps is a way of working in which software development and operations share one responsibility: getting changes to users quickly and safely, and keeping the service stable. It rests on three things: a culture of shared ownership, automation of the path from code to production, and measurement with numbers. A job title or a set of tools is not DevOps. If you cannot say, with numbers, how long a change takes to reach users and what share of deployments cause problems, you don't have DevOps yet, whether you run an in-house team or have outsourced the work.

Most writing about DevOps is aimed at people who want to become DevOps engineers: a definition, a list of tools and a learning path. This guide is for the people who have to make decisions about DevOps: the CTO, tech lead or IT manager who wants to know where their team stands, what to measure, and, if they hand part of the work to another team, exactly what they should get in return.

What is DevOps?

DevOps combines Development and Operations. For years, these two teams had opposing goals in most companies. Development was measured by new features shipped, operations by service stability. The result was a wall: code was thrown over one side, and someone on the other side had to keep it alive. Every release was a tense event, and every outage started a new argument.

The word came from a conference. Patrick Debois organized the first DevOpsDays in Ghent, Belgium, in October 2009. He was inspired by John Allspaw and Paul Hammond's well-known talk at that year's Velocity conference, "10+ Deploys per Day: Dev and Ops Cooperation at Flickr". The conference name was shortened and became the name of a movement.

A more precise definition is the CALMS framework. John Willis and Damon Edwards first proposed four of its letters, and Jez Humble added the L:

From a wall between teams to a shared flow: the traditional split between development and operations compared with the DevOps model
From a wall between teams to a shared flow: the traditional split between development and operations compared with the DevOps model

What DevOps is not

Three common readings of DevOps cause the most damage in practice:

DevOps starts with team culture

If you remember one sentence from this guide, make it this: the team that builds something shares responsibility for running it. When developers know a 3 a.m. failure reaches them too, they write different code: better logs, more tests, smaller changes.

DevOps culture shows up in specific behaviours, not slogans:

The signs of a culture that is not DevOps yet are familiar too: releases only on Thursday nights and only when one particular person is present; "it worked on my machine"; a server nobody dares to restart; and passwords passed around in a chat group.

What should be automated

Culture does not last without automation. If every deployment takes two hours of manual work, the team ends up postponing deployments, changes pile up, and every release gets riskier. These six areas are the technical foundation of DevOps:

  1. Everything in version control. Not just application code: configuration, infrastructure definitions, database scripts and the pipeline itself live in Git. Every change has a history and a reviewer.
  2. CI/CD. Every change is built and tested automatically and reaches production through a repeatable path. Rolling back is automated too. We described a real example of this path in From terrifying deploys to zero-downtime.
  3. Infrastructure as code. Servers, networks and configuration are defined with tools such as Terraform or Ansible, not by clicking in a console. Infrastructure defined in code can be rebuilt; infrastructure that lives only in someone's memory cannot.
  4. Observability. Metrics, logs and traces are arranged so the team sees a problem before customers do. We explained why logs alone are not enough in a practical guide to distributed tracing.
  5. Security in the pipeline. Code and image scanning is part of the deployment path, not something someone remembers once a year.
  6. Tested backup and recovery. A backup whose restore has never been tested is only an assumption.

How it works in our own team

At Dropp Tempo, every change passes a quality gate before it reaches production: SonarQube checks code quality and common vulnerabilities, and Trivy scans container images and dependencies for known vulnerabilities. A change that does not pass the gate is not released.

We have also recently moved our own infrastructure to Kubernetes managed with Rancher, and we deploy with ArgoCD using GitOps. In this approach, the desired state of the system is defined in Git and ArgoCD keeps the cluster in sync with it. Every deployment is a commit, and so is every rollback. The details of this migration, including what surprised us along the way, deserve an article of their own.

How do you know DevOps is working?

Without numbers, "we do DevOps" is just a claim. The DORA research program, now part of Google, has studied software delivery performance across thousands of teams for years. Its framework today has five metrics in two groups:

Throughput

Instability

The DORA metrics for measuring DevOps: three throughput metrics and two instability metrics
The DORA metrics for measuring DevOps: three throughput metrics and two instability metrics

The important point is that these metrics measure speed and stability together. A team that ships faster but whose fail rate has gone up has not improved; it just delivers problems to users faster. The reverse is also true: a team that stays stable by shipping less pays for it in a slower product.

Alongside these five metrics, two operational numbers should be clear: a service level objective (SLO) for each important service, such as the share of successful requests over a defined window, and time to detect, the gap between a problem starting and someone knowing about it. If customers report most of your problems, you don't have enough eyes on the system yet.

You don't need a complex dashboard to start. A monthly table with these few numbers is more honest than any "everything is fine" report.

When it is worth it, and when it is not

DevOps principles are worth it for any team running software in production. But the size of the investment should match the size of the risk. Our engineering verdict:

Our rule of thumb is simple: repeatability first, then speed, then scale. Any tool that breaks this order has probably arrived too early.

DevOps in restricted and regulated environments

The principles above are universal, but many teams also work under constraints that most DevOps guides ignore: export controls, restricted networks, unstable international connectivity, regulated industries and data residency rules.

Dependence on external services that can disappear overnight. Docker Hub has applied pull rate limits since 2020, and it blocks access from regions under US export controls. Public registries, package mirrors and hosted Git services can change their terms, limits or availability with little notice. The lesson is not which service is open today; it is that access can change in either direction, and your pipeline should not depend on it.

The practical answer has several layers:

Unreliable international connectivity. If your service is hosted in one region but needs foreign APIs, a foreign CDN, or even fonts and scripts from an external domain to work, it effectively stops during connectivity disruptions, even if your servers are perfectly healthy. Every external dependency should be identified, and for each one it should be clear what happens when it is unavailable.

Local and sovereign clouds. Regulated organizations often need their data and workloads to stay within a country. Local cloud providers offer managed Kubernetes, object storage and CDN with stable local access, but their range of services and infrastructure-as-code tooling is usually narrower than the global clouds. Our advice is provider-neutral: define your infrastructure so that moving between providers is a project of a few weeks, not a crisis.

Hiring, a managed team, or a hybrid

Once you decide to take DevOps seriously, the next question is who will do it. There are four common models:

Comparing the real cost of these models and their break-even point is a topic for a separate article. Here we focus on the part that is usually overlooked: if you hand any part of DevOps to another team, what the contract must guarantee.

From culture to contract: what a DevOps contract must cover

A DevOps contract is really the culture of shared ownership written in legal language. A contract that only says "server support" guarantees almost nothing. Check these nine clauses in any DevOps contract, project-based or ongoing.

  1. Scope in terms of services, not hours. Which services, which environments (production, staging) and which tasks are inside the contract, and which are outside it. "Everything" means nothing.
  2. Division of responsibility. For every area, including application code, infrastructure, databases, security and cloud cost, it should be clear who executes, who approves and who is only informed.
  3. An SLA with a measurement definition. An availability number means nothing without a definition. It must be clear for which service, over what window, with which tool and from where it is measured, and whether planned downtime counts. For example, in the Hypernyx project, core endpoint uptime was above 99.9% over a 90-day measurement period: one number, with its service and its window.
  4. Response times by severity. A full outage, a partial degradation and a routine request need different response times. Each level needs a definition, a response time and a clear escalation path.
  5. Real on-call. Who is reachable, during which hours, through which channel, and whether the support team has access to logs and dashboards or only to a phone number.
  6. You own everything. Source repositories, infrastructure code, cloud accounts, domains, keys and secrets must be in your name and under your ownership. The external team gets access, not ownership. This is the most important clause on this list.
  7. Documentation as a deliverable. Architecture, runbooks and recovery procedures are part of the contract's output and have an update schedule.
  8. A monthly report with numbers. The same metrics as above: deployments, failures, recovery time, availability and incidents, with a postmortem for every serious incident.
  9. An exit and handover clause. If the engagement ends, how and within what time knowledge, access and documentation are handed over. A contract that is hard to leave holds you hostage.
Division of responsibility in a DevOps contract: what belongs to the client, to the DevOps team, and what is shared
Division of responsibility in a DevOps contract: what belongs to the client, to the DevOps team, and what is shared

What you should not accept

At Dropp Tempo, every engagement starts with an audit of the current infrastructure, its risks and bottlenecks, which usually takes one to two weeks. The SLA is defined from day one, with written response times, availability and responsibilities, and existing infrastructure is changed only when there is a clear reason to change it.

Maturity checklist: where is your team?

Read these four levels from the bottom up. The level where you can answer "yes" to every item is your current level. The first "no" shows you what to work on next.

Four levels of DevOps maturity: manual, scattered automation, standardized and measured
Four levels of DevOps maturity: manual, scattered automation, standardized and measured

Level 1: Manual

Level 2: Scattered automation

Level 3: Standardized

Level 4: Measured

Most teams we see are between levels 2 and 3. The good news is that moving from 2 to 3 takes discipline more than expensive tools.

What Dropp Tempo does in this area

Dropp Tempo is Dropp's infrastructure and operations practice. For companies that don't want to, or can't, build a full in-house DevOps team, it works as a managed DevOps team: designing and maintaining CI/CD, infrastructure as code, observability, security in the pipeline, and on-call and incident response under a written SLA. If you want to know which level of this checklist your team is at, the initial infrastructure audit is where that starts.

Frequently asked questions

What is DevOps in simple terms?

DevOps is a way of working in which development and operations share one responsibility: getting changes to users quickly and safely and keeping the service stable. It relies on three things: a culture of shared ownership, automation of the path from code to production, and measuring results with numbers.

What is the difference between DevOps and SRE?

DevOps is a set of principles and a working culture. SRE (Site Reliability Engineering) is a specific way of putting those principles into practice, shaped by Google and described in Google's SRE book. SRE uses tools such as SLOs and error budgets to decide when to speed up releases and when to slow them down in favour of stability.

What does a DevOps engineer do, and is one enough?

A DevOps engineer builds and maintains the path from code to production, the infrastructure, observability and operational security. One person can be a good start, but one person alone has no 24/7 coverage and no backup. If your service must not be left unattended at night, you need more than one person or a supporting team.

Does a small company need DevOps?

Its principles, yes; its heavy tools, usually not. Code and configuration in Git, a simple pipeline, tested backups and outage alerts are necessary for any team running software in production. Leave Kubernetes and microservices for when you have a problem they solve.

How is DevOps different from Agile?

Agile is mostly about how software is built: working in short cycles with fast feedback from users. DevOps extends the same logic to releasing and running software. A team that has a release ready every two weeks but ships once a month has Agile but not DevOps.

How long does it take to implement DevOps?

It depends on where you start. An audit of the current state usually takes one to two weeks, and basic automation, such as a deployment pipeline and alerting, is among the first changes whose effect you can see. Changing the culture and reaching a level where everything is measured takes longer, because it is about team habits, not installing tools.

By the Dropp Tempo Engineering Team