↓ Skip to main content

Understanding the Software Development Life Cycle (SDLC)

886 words·5 mins· loading · loading ·
Table of Contents
Mysteries of DevOps - This article is part of a series.
Part 1: This Article

Every piece of software, from a shell script to a banking system, goes through the same stages: someone decides what it should do, someone designs it, someone builds it, someone checks it, it gets released, and then it has to be kept alive. The Software Development Life Cycle (SDLC) is the name for that sequence.

The phases are easy to memorise. What’s more useful to understand is where they go wrong, because that’s the problem DevOps exists to solve. This post covers the phases, the main ways teams arrange them, and the gap between phases that makes software late and fragile.


The six phases
#

Phase The question it answers What it produces
Requirements What should this do, and for whom? A list of needs and constraints
Design How will it be built? Architecture, data model, technical decisions
Implementation Can we build it? Code
Testing Does it do what was asked? Test results, bug reports
Deployment Can people use it? A running release
Maintenance Does it keep working? Fixes, updates, monitoring, the next set of requirements

Two things are easy to miss in a table like this.

First, maintenance is the longest phase by far. Building something takes weeks or months. Keeping it running takes years, and most of the cost of software lands here.

Second, the last phase feeds the first. Bugs, user requests and outages in maintenance become the requirements for the next round. It’s a cycle, not a line, which is the whole point of the name.


Three ways to arrange the phases
#

The phases don’t change much between teams. The arrangement does.

Model How it works Good for The catch
Waterfall Each phase finishes completely before the next one starts Fixed, well-understood requirements (some regulated or contract work) You find out the design was wrong only after it’s built and tested
Iterative Build a smaller version, go through all phases, then repeat with more Large systems where the requirements firm up as you go Needs discipline to stop each round growing into a waterfall
Agile (Scrum, Kanban) Very short cycles, one to two weeks, each delivering working software Products where users’ needs change and feedback matters Easy to ship often without ever stepping back to design

Most real teams mix these. The useful question isn’t “which model are we?” It’s “how long does it take us to find out we were wrong?”


Where it goes wrong: feedback arrives late
#

Each phase hands its output to the next, and each one assumes the previous one got it right. Mistakes don’t announce themselves at the handoff. They surface later, in a phase that didn’t make them, when they’re more expensive to fix.

Here’s a small, real example from my own homelab, Project Aether.

I wrote a nightly backup script for my app server. The requirement was clear: back up the databases, and send a “heartbeat” to my monitoring system when the backup succeeds, so I’d get an alert on any night it didn’t. I designed it, built it, ran it by hand, and saw “Backup Complete!” in the output. I put it on a schedule.

Later, in maintenance, an audit found that the heartbeat had never once arrived. A quoting bug in a config file turned the heartbeat URL into an empty string, and the script was written to ignore every error, so it printed “Backup Complete!” no matter what happened. The monitor had been red since the day I created it, and because it was always red, I’d stopped looking at it.

Trace that back through the phases:

  • Requirements said “alert on a missed backup”. Correct.
  • Design said “send a heartbeat at the end”. Correct.
  • Implementation had the bug.
  • Testing checked that the script ran, not that the heartbeat arrived. It only tested the happy path.
  • Deployment put an untested failure path on a nightly schedule.
  • Maintenance found it, much later.

One bug, made in one phase, found four phases later. The fix itself took an afternoon. Finding it took far longer. (The full story is in Green Is Not a Status.)

That gap, between where a mistake is made and where it’s found, is the real problem with the SDLC as a sequence of handoffs. It doesn’t matter whether the team calls itself waterfall or agile. If each phase only checks its own output and trusts the rest, feedback arrives late.


What closes the gap
#

There are three broad fixes, and they come up again and again in this series:

  1. Shorter cycles. If the whole loop takes a day instead of six months, a mistake can only hide for a day.
  2. Automated checks at every handoff. Tests that run on every change, including tests that break things on purpose and check that the failure is noticed. My backup script has one now: I break a database dump deliberately and confirm that no heartbeat is sent.
  3. One team owning the whole cycle. When the people who build something also run it, they feel the cost of maintenance directly, and they design for it from the start.

Reference: Introduction to SDLC in my knowledge base, for more on the models and how security fits into each phase (DevSecOps).

Those three ideas, taken together, are most of what DevOps means. The next post covers how DevOps changes each phase of the SDLC.

Mysteries of DevOps - This article is part of a series.
Part 1: This Article

Related