DevOps is a blend of the words development and operations. It means a way of working in which developers and operations staff don’t hand the software over to each other, but are jointly responsible for it throughout its whole life: from writing it, through deployment, to running in production. The goal is frequent, small and reliable releases.
So DevOps isn’t a program you can install, and it isn’t a job title either – although “DevOps engineer” is a common role today. It is first and foremost a mindset, made tangible by a few well-defined practices and tools.
Where does DevOps come from?
In traditional organisations, development and operations were two separate teams with different goals. Developers were valued for delivering new features – in other words, change. Operations staff were valued for keeping the system running stably – in other words, for the absence of change. Between the two stood a “wall”: developers threw the finished code over it, and operations tried to make it work in production.
The result was infrequent, large, risky releases, and the two teams pointing fingers at each other when something went wrong. The term DevOps caught on in 2009, around the first DevOpsDays conference (Ghent, Belgium), and it was a response to this problem: if the two teams work towards a shared goal with shared tools, change and stability don’t exclude each other.
What does it mean in practice?
DevOps is often summarised with the acronym CALMS:
| In practice | |
|---|---|
| Culture | Shared responsibility, blameless incident analysis |
| Automation | CI/CD, infrastructure as code, automated tests |
| Lean | Small steps, fast feedback, no unnecessary waiting |
| Measurement | Monitoring, logging, metrics of the release process |
| Sharing | Shared documentation, knowledge sharing, shared on-call |
These turn into the following concrete practices:
- Everything in version control. Not just the application code, but the descriptions of the servers, containers and pipelines also live in Git.
- CI/CD. Every change is automatically built, tested and made release-ready. We have a separate article on this: What is CI/CD?
- Infrastructure as code. Servers and cloud resources can be built from files that describe them (Ansible, Terraform and the like), without clicking around by hand, and rebuilt at any time.
- Identical environments. The development, test and production environments are created from the same description, for example from the same Docker image.
- Monitoring and alerting. The team knows about a fault before the client does, and sees what effect each release had.
- Small, frequent releases. With a small change it is easy to find what broke the system, and easy to roll back.
How can DevOps be measured?
For a long time, the DORA (DevOps Research and Assessment) research group, part of Google, described how well a team’s software delivery works with four metrics:
- Deployment frequency: how often a new version goes to production.
- Change lead time: how much time passes between a commit and its production release.
- Change fail rate: what percentage of releases cause a fault that has to be fixed or reverted immediately.
- Failed deployment recovery time: how long it takes for the service to recover after a faulty release.
In 2024, DORA added a fifth: the rework rate, that is, the share of unplanned releases made necessary by a production fault. Together, the metrics measure speed and stability. The most important lesson of the research is that the two aren’t opposites: the best-performing teams are fast and stable at the same time – precisely because they release often, in small steps.
What isn’t DevOps?
- It isn’t a tool. A Jenkins server or a Kubernetes cluster isn’t DevOps just because the team uses it.
- It isn’t developers running all the operations. Operations knowledge doesn’t disappear, it just becomes part of the team, and much of the work gets automated.
- It isn’t only for big companies. In a small team it can be introduced faster, because there are fewer organisational boundaries.
- You don’t need Kubernetes for it. A well-automated Docker Compose setup or a managed cloud service is simpler and cheaper in many cases.
What does a DevOps engineer do?
A DevOps engineer is typically the specialist who builds and maintains the automation between development and operations: writes CI/CD pipelines, manages infrastructure as code, containerises, designs cloud environments and sets up monitoring. Ideally they don’t “do DevOps” alone, but give developers tools they can use to release safely themselves.
Related concepts
| Concept | What does it mean? |
|---|---|
| DevSecOps | Building security checks (dependency scanning, secret detection, vulnerability scanning) into the pipeline, rather than leaving them until after the release |
| GitOps | The desired state (what should run, with what settings) is described in a Git repo, and the system adapts to it; a change is a commit. A practical example: Moving a PHP application into containers with a GitOps approach |
| SRE | Site Reliability Engineering: an approach developed at Google that treats operations as a software engineering task, with measurable reliability targets |
| Platform engineering | Building an internal developer platform on which teams can spin up environments and release in a self-service way |
Where should a team of 3–10 people start?
A small development team doesn’t need a reorganisation or a new position to work with a DevOps mindset. A proven order:
- Put everything under version control, including server settings and deployment steps.
- Automate the tests, so that they run on every push.
- Containerise the application, so that the developer machine and the server run the same thing.
- Automate releases: first to the test environment, then with a one-click production deployment.
- Set up monitoring and alerting, so that you don’t find out about a fault from a client.
- Write down and test the rollback, including restoring from backup.
Many small teams have no operations person of their own, and it wouldn’t be a full-time job anyway. In that case it works well if an external partner builds the pipeline, the infrastructure and the monitoring, and the team then uses them day to day on its own. We help with this through our Cloud and DevOps service.