4. The Development Lifecycle — Overview
The eleven phases every software project goes through, from planning to maintenance.
Part 4: The Universal Development Lifecycle
The phases every project moves through — from one-person blogs to billion-user platforms.
Read the first five phases (planning → implementation) now — they frame how real projects work. Skim CI/CD, observability, and maintenance until you've shipped something; they'll make more sense after Roadmap Stage 9. Return for legacy code and estimation once you've maintained a project for a few months.
What this chapter is really about: Real software isn't written in one go. It moves through phases — somebody decides what to build, somebody designs it, somebody writes the code, somebody else reviews it, automated systems test it, it gets shipped to users, and then it gets monitored and maintained forever.
Why this matters before you learn any framework: Frameworks (Next.js, React, Django) only solve the "writing the code" phase. The other phases — planning, design, code review, deployment, monitoring — are what actually consume most of your time as a working developer. Understanding the full loop helps you see where each tool fits.
Mental model: Think of building a product like building a restaurant. You don't just start cooking. First you decide what kind of restaurant (planning), draw up the floor plan (design), build the kitchen (architecture + setup), hire and train staff (team setup), cook test meals (implementation + testing), have a soft opening with friends (code review + staging), open to the public (deployment), and then keep the place running every day (observability + maintenance). Software has the exact same arc.
Jargon you'll meet: requirements, PRD, wireframe, system design, architecture, repository, branch, pull request, code review, CI, CD, staging, production, observability, on-call, incident, post-mortem.
If you only remember one thing: Writing code is maybe 20% of a software engineer's actual job. The other 80% is everything in this chapter.
Software development has a recognizable rhythm. The complexity of each phase varies dramatically by scale, but the phases themselves are universal. A solo developer in a coffee shop and a 5,000-engineer organization both go through these steps; one just does each one in five minutes while the other takes five weeks.
The eleven phases
Reading this diagram: The dotted line back from Phase 12 to phase 1 is the most important arrow on the page. These aren't strictly sequential — modern development is iterative, with constant feedback loops. But every feature, every bug fix, every refactor goes through these stages in some form.
Pages in this chapter
- Phase 1: Discovery & Planning
- Phase 3: Design
- Phase 4: Architecture
- Phase 5: Environment Setup
- Phase 6: Implementation
- Phase 7: Testing
- Phase 8: Code Review
- Phase 9: CI/CD
- Phase 10: Deployment & Hosting
- Phase 11: Observability
- Phase 12: Maintenance & Iteration
Each page covers one phase with worked examples, anti-patterns, and concrete tooling recommendations for 2026.
When you finish, move on to Chapter 5: Tech Stack, Decoded.