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:
- Culture: shared responsibility for the outcome, not for "my part of the job".
- Automation: every repetitive step between code and production, from testing to deployment and building infrastructure, is automated and repeatable.
- Lean: changes ship small and often, not large and once a month.
- Measurement: decisions are made with data, not gut feeling.
- Sharing: knowledge lives in documents and runbooks, not in one person's head.
What DevOps is not
Three common readings of DevOps cause the most damage in practice:
- A job title. Hiring one "DevOps engineer" and handing them every server is the old operations team with a new name. The wall is still there; now one person stands behind it.
- A tool. Kubernetes, Jenkins and ArgoCD are good tools, but installing them does not create DevOps. A team that still ships once a month, nervously, will ship nervously on Kubernetes too.
- A one-off project. DevOps does not end at "setup". A pipeline nobody maintains is as fragile six months later as it was on day one.
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:
- Every service has a clear owner. For each service, it is known who decides, who gets alerted and who changes it.
- After every outage, the system is reviewed, not the people. The right question is "why did our system allow a human mistake to do this much damage?" We wrote about this in detail in Blameless postmortems.
- Knowledge is written down. Restarting a service, restoring a backup and rotating secrets are in runbooks. Whoever is on call tonight does not need to phone someone on holiday.
- Access is role-based. Everyone has access to what their work needs. When someone leaves the team, their access is closed the same day.
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:
- 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.
- 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.
- 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.
- 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.
- Security in the pipeline. Code and image scanning is part of the deployment path, not something someone remembers once a year.
- 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
- Change lead time: how long a change takes from commit to running in production.
- Deployment frequency: how often you deploy.
- Failed deployment recovery time: when a deployment fails, how long it takes to get back to a healthy state.
Instability
- Change fail rate: the share of deployments that need immediate intervention, such as a rollback or hotfix.
- Deployment rework rate: the share of deployments that are unplanned and made to fix a problem in production.
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:
- The minimum for every team, even a team of three: code and configuration in Git, a simple pipeline that automates testing and deployment, automatic backups with a tested restore, and alerts for outages. These are cheap at the start and expensive later.
- When more investment pays off: your service moves money or holds sensitive data; an hour of downtime has a direct cost or damages your reputation; several teams work on one product; or you have a contract with a customer that commits you to an availability level.
- What usually comes too early: Kubernetes, microservices or multi-cloud infrastructure before you have a problem they solve. Each carries a permanent operational cost. If a team cannot reliably ship one service to one server, it will not ship twenty services to a cluster.
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:
- A private registry and internal mirror for container images, so builds do not depend on live access to Docker Hub.
- Pinning images by digest, not only by tag, so exactly what was tested is what ships.
- Caching dependencies (npm, pip, Maven and the like) inside your own infrastructure.
- Self-hosted source control. For clients who don't want to depend on GitLab.com or another external service, we deploy self-hosted GitLab on their own infrastructure, with runners, a registry and backups.
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:
- In-house team: full control and knowledge inside the organization, but hiring is slow and one person becomes a single point of failure. Their holiday or resignation means a system nobody fully understands.
- DevOps as a service (project-based): for a defined, limited job, such as setting up CI/CD or a migration. After handover, maintenance is your team's job.
- Managed DevOps team: an external team continuously acts as your DevOps department, with on-call and an SLA. It provides coverage and documented knowledge, provided the contract is written well.
- Hybrid: an in-house engineer who owns the infrastructure, alongside an external team for 24/7 coverage, specialist work and backup.
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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Documentation as a deliverable. Architecture, runbooks and recovery procedures are part of the contract's output and have an update schedule.
- A monthly report with numbers. The same metrics as above: deployments, failures, recovery time, availability and incidents, with a postmortem for every serious incident.
- 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.
What you should not accept
- "Unlimited support" without definitions of severity and response time. Unlimited usually means undefined.
- An availability number without a measurement method. If you don't ask where it is measured, it is probably measured somewhere that is always green.
- Accounts and access in the external team's name. The day the engagement ends, this means a system whose keys you don't hold.
- No exit clause. Every good engagement also needs a clear way to end.
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.
Level 1: Manual
- Code is in Git, but deployment is manual, using commands only one or two people know.
- Backups are taken, but nobody has tested a restore recently.
Level 2: Scattered automation
- Build and test are automated, but each project does it its own way.
- Outage alerts exist, but users still report most problems.
Level 3: Standardized
- All projects ship through one shared deployment path with automatic rollback.
- Infrastructure is defined in code and can be rebuilt from that code.
- Security scanning of code and images is part of the pipeline.
- Core services have runbooks and a defined on-call rotation.
Level 4: Measured
- DORA metrics are measured and reviewed every month.
- Important services have written SLOs, and the team plans to meet them.
- A postmortem is written after every serious incident, and its actions are followed up.
- Restores from backup are tested regularly, and their duration is 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