{"canonical_url":"https://engineer.company/glossary/devops/","content_markdown":"# DevOps\n\n## What it is\n\nDevOps is a way of organising software work in which the people who write a\nsystem also own how it is built, released and kept running, and the steps\nbetween writing code and running it are automated rather than handed from one\nteam to another. The name is a blend of development and operations, the two\ngroups it was coined to bring together.\n\nNIST, the US National Institute of Standards and Technology, defines it as\npractices for automating the processes between development and operations teams\n\"so that they can build, test, and release software faster and more reliably\".\nThat definition is useful because it names the part that matters: the\nprocesses in between. A company can have excellent developers and excellent\noperators and still lose days at the point where one hands a release to the\nother.\n\nIn practice, DevOps shows up as a handful of habits that reinforce each other:\n\n- **Shared ownership of production.** Whoever changes the code sees what the\n  change does once it runs, through monitoring, logs and alerts, and answers\n  for it.\n- **An automated path to release.** Build, test and deployment run as a\n  pipeline, the same way every time, usually on top of\n  [CI](https://martinfowler.com/articles/continuousIntegration.html).\n- **Infrastructure written as files.** Servers, networks and databases are\n  described in templates or playbooks kept beside the code, so an environment\n  can be rebuilt instead of remembered.\n- **One build, many environments.** The artefact that passed its tests in\n  staging is the same one that reaches production, with only its settings\n  changed.\n- **Small, frequent releases.** Each one carries few changes, so a fault is\n  easy to find and easy to roll back.\n\nDevOps is not a product, and it is only loosely a job title. Vendors sell tools\nunder the name and companies hire \"DevOps engineers\", but neither is the thing\nitself. A DevOps engineer usually builds and looks after the pipelines and\ninfrastructure that let other developers ship on their own, which is a role\ninside the practice rather than a substitute for it.\n\n## Why it matters\n\nEvery hand-off between teams loses something. The developer knows why a change\nwas made and what it depends on; the operator knows what the servers look like\nand what broke last month. When a release crosses from one to the other as a\nticket and a package, both halves of that knowledge arrive incomplete, and the\ngaps surface during deployment, which is the most expensive time to find them.\n\nThe [Twelve-Factor App](https://12factor.net/), a methodology for how\nsoftware-as-a-service apps are built, names three of those gaps precisely. There\nis a gap in time, when code written today reaches production weeks later. There\nis a gap in people, when one group writes the code and another deploys it. And\nthere is a gap in tools, when a laptop runs one database and production runs\nanother. DevOps is largely a project to close all three: deploy hours after\nwriting, let the authors deploy, and keep every environment as alike as\npossible.\n\nRelease size is the second argument. Google's book on site reliability\nengineering puts it plainly: frequent releases mean fewer changes between\nversions. A release with three changes in it is easy to reason about when it\ngoes wrong. A release with three hundred is a search.\n\nThe third is toil. The same book defines toil as work tied to running a service\nthat is manual, repetitive, automatable and without lasting value, and that\ngrows in step with the service. A team that restarts a process by hand every\nTuesday, renews certificates from a calendar reminder and resizes disks when an\nalert fires is spending its time on work that a script would do more reliably.\nAutomating that work is how a small team keeps up with a growing system.\n\nSecurity guidance has settled on the same shape.\n[NIST's guidance on DevSecOps for cloud-native applications](https://csrc.nist.gov/pubs/sp/800/204/c/final)\nstarts from a pipeline with stages for building, testing, packaging, deployment\nand operations, and counts infrastructure, runtime policy and monitoring among\nthe kinds of code that pipeline describes.\n\n## What it looks like in practice\n\nThe pages on this site show DevOps less as a title than as a scope of\nresponsibility: the same engineer designing a system, getting it to production\nand keeping it there.\n\nFor a mapping product, the founder's work\n[spanned infrastructure, data processing and the customer-facing map application for two years](/portfolio/a-mapping-product-carried-end-to-end/).\nThe work covered architecture, implementation and support across those layers:\ndesigning, building and maintaining the operating environment, data-processing\nworkflows and map application. That connects development and operations in one\nengagement. The record establishes the scope and duration of that engineering\nand maintenance, rather than uptime or response-time measurements.\n\nOn a database estate of 10 PostgreSQL and MS SQL Server instances on Ubuntu\nLinux VPS, the operational side was automated piece by piece:\n[backups through `pg_dump` and SQL Server Agent jobs, monitoring in Prometheus and Grafana](/portfolio/ran-10-postgresql-and-ms-sql-servers-on-ubuntu/),\nregular patching, UFW firewalls, role-based access control and documented\ndisaster recovery. The page reports 99.9% uptime across all ten servers and\nmanual maintenance cut by 50% through automation, which is the toil argument\nmeasured on one estate.\n\nOn an Azure platform with development, staging and production environments,\n[deployment was owned end to end along a fixed route](/portfolio/owned-end-to-end-platform-deployments-to-azure/).\nOwning it meant owning every link in that path: CI/CD builds the\nimages, Bicep templates keep each stage on matching infrastructure, and the\nsettings particular to each stage are held separately from secrets. One\nbuilt artefact is therefore promoted from stage to stage instead of rebuilt for\neach, and changes reach every environment predictably, without a single ad-hoc\nmanual deploy.\n\n## Where it goes wrong\n\nDevOps fails quietly, usually by keeping the vocabulary and losing the habits.\n\n**The title arrives and the wall stays.** An operations team is renamed, or a\n\"DevOps team\" is hired to sit between the developers and production. Releases\nstill cross a hand-off; it just has a new name on the other side. The test is\nsimple: ask who can ship a change and who gets woken when it breaks. If those\nare different people with different information, the practice has not arrived.\n\n**Deployment is still a person following a checklist.** The pipeline builds\nand tests, and then someone logs in to a server and runs the last five steps\nfrom memory, slightly differently each time. Put the last steps in the pipeline\ntoo, give releases one route through the environments, and treat a manual push\nto production as an incident to explain.\n\n**Each environment gets its own build.** Rebuilding for staging and again for\nproduction means the thing that was tested is not the thing that shipped. A\ndependency that resolved differently on the second build turns up as a fault\nnobody can reproduce. Build once, tag the artefact with the commit it came from,\nand promote that artefact, with settings coming from the environment:\n\n```sh\ntag=\"$(git rev-parse --short HEAD)\"\ndocker build -t \"registry.example.com/app:$tag\" .\ndocker push \"registry.example.com/app:$tag\"\n# staging and production run this same tag;\n# only the settings they start it with differ\ndocker run --env-file staging.env \"registry.example.com/app:$tag\"\n```\n\n**Staging drifts away from production.** A setting changed by hand on one\nserver, a database upgraded in production first, a library version pinned in\none place and floating in another: each makes staging a little less useful as\na rehearsal. Describe the infrastructure in templates, apply the same templates\neverywhere, and run the same backing services in development that production\nruns.\n\n**Toil grows with the system.** Manual jobs that took ten minutes a week for one\nserver take hours for twenty. Without a deliberate budget for automating them,\nthe team ends up spending its days keeping the lights on. Count the recurring\nmanual work, and cap the share of time it is allowed to take.\n\n## Further reading\n\n- [DevOps](https://csrc.nist.gov/glossary/term/development_operations) — the\n  NIST definition, with the special publications it is drawn from.\n- [Build, release, run](https://12factor.net/build-release-run) — why a build\n  is made once and combined with configuration to form a release.\n- [Dev/prod parity](https://12factor.net/dev-prod-parity) — the gaps in time,\n  people and tools between development and production, and how to close them.\n- [Config](https://12factor.net/config) — keeping everything that varies\n  between deploys out of the code and in the environment.\n- [Eliminating Toil](https://sre.google/sre-book/eliminating-toil/) — Google's\n  definition of toil and the case for capping it.\n- [Release Engineering](https://sre.google/sre-book/release-engineering/) —\n  hermetic builds, self-service releases and policies enforced by the release\n  tooling.\n\n\u003chttps://engineer.company/glossary/devops/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"What DevOps means in practice: who owns production, which steps get automated, how releases move between environments, and how the idea gets hollowed out.","formats":{"gemtext":"https://engineer.company/glossary/devops/index.gmi","gopher":"https://engineer.company/glossary/devops/gophermap","html":"https://engineer.company/glossary/devops/","json":"https://engineer.company/glossary/devops/index.json","markdown":"https://engineer.company/glossary/devops/index.md","pdf":"https://engineer.company/glossary/devops/index.pdf"},"kind":"page","language":"en","title":"What is DevOps?","url":"https://engineer.company/glossary/devops/","version":1}