The previous post ended on the real problem with the SDLC: mistakes are found late, in a phase that didn’t make them. A large part of that comes from who does each phase. In a traditional setup, developers own requirements to testing, and an operations team owns deployment and maintenance. They’re measured on different things, and that’s where the friction starts.
This post covers where that friction comes from, what DevOps changes in each phase of the SDLC, and what that looks like in a real system.
Two teams, two goals #
Developers are rewarded for change: new features, shipped quickly. Operations teams are rewarded for stability: nothing breaking, ever. Both goals are reasonable. Put them in separate teams and they pull against each other.
| Developers | Operations | |
|---|---|---|
| Measured on | Features delivered | Uptime, incidents |
| Change is | The job | The main cause of outages |
| A release is | The finish line | The start of the risk |
| When it breaks in production | “It worked on my machine” | “We didn’t build it, we just run it” |
The usual result is the “wall of confusion”: developers throw a release over the wall, operations catches it, and when it breaks, each side has a reasonable argument that it’s the other side’s problem. Releases get bigger and rarer because each one is painful, and bigger releases break in bigger ways.
DevOps is the set of practices and the culture that take that wall down. Not by merging two job titles into one, but by giving both sides the same goal: changes that reach users quickly and keep working.
What DevOps changes in each phase #
| SDLC phase | Traditional | With DevOps |
|---|---|---|
| Requirements | Features only | Features plus how it will be run, monitored and recovered |
| Design | Application architecture | Architecture plus deployment, failure modes and observability |
| Implementation | Code in long-lived branches, merged rarely | Small changes merged often (continuous integration) |
| Testing | A separate phase, near the end | Automated tests on every change |
| Deployment | Manual, rare, risky, often at night | Automated and repeatable, small enough to be boring (continuous delivery) |
| Infrastructure | Servers set up by hand, each slightly different | Servers and networks described in code (infrastructure as code) |
| Maintenance | Operations finds out from users | Monitoring finds out first, and feeds the next cycle |
The common thread is feedback. Every change in that table makes a mistake show up sooner, closer to the person who made it.
What it looks like in practice #
The practices are easier to understand in a real system than in a definition. Here’s how they show up in Project Aether, the homelab I run. It’s one person, not two teams, but the same ideas apply, because “dev me” and “ops me” still want different things on different days.
Infrastructure as code. Every virtual machine starts from the same template, and Terraform clones it with a defined name, size and network. If a machine breaks, I don’t repair it by hand. I destroy it and let Terraform build an identical one. (More on the template.)
Continuous delivery with GitOps. The Kubernetes cluster’s desired state lives in a Git repository. A tool called ArgoCD watches that repository and applies changes within about three minutes of a commit. If someone changes something directly in the cluster, ArgoCD puts it back the way Git says. Deployment stops being an event and becomes a merge.
Monitoring from outside. A small cloud server, separate from everything else, checks that my services answer and that my nightly backup checks in. When the hypervisor crashed one morning, the alert reached my phone within four minutes, because the thing raising it was outside the thing that failed.
Learning from incidents. Every real failure gets a written review: what happened, the timeline, the root cause, what went well, and what changed. The reviews don’t assign blame. They look for the conditions that let a reasonable decision cause a problem, because those conditions will cause the next one too.
None of this needed a big team or expensive tools. It needed the decision that the person who builds a thing is also responsible for how it runs.
What DevOps isn’t #
A few common misunderstandings are worth clearing up early:
- It isn’t only a job title. “DevOps engineer” is a real role in most companies today, but DevOps itself is a way of working. A team that hires a DevOps engineer and keeps the wall in the middle hasn’t adopted DevOps.
- It isn’t a tool. Jenkins, GitHub Actions, Docker and Kubernetes support DevOps practices. Installing them doesn’t create the practices.
- It isn’t “move fast and break things”. The research behind the book Accelerate found that teams who deploy more often also have fewer failed changes and recover faster. Speed and stability stop being a trade-off when changes are small and checked.
The next post is a map of the skills and practices DevOps involves, and where to start with each.