- Atlas
- Computer Science
- Software Process Models
Software Process Models
Software process models are the frameworks a team uses to organize the making of software: what happens in what order, who does it, what gets written down, and how the work is checked and changed.
11 frameworks, from 1968 to today · Software Engineering · Computer Science
- Systems development life cycle 1968-Present
- Waterfall Model 1970-2000
- Incremental build model 1980-Present
- Spiral Model 1986-2005
- Capability Maturity Model 1991-2010
- Scrum 1995-Present
- Rational Unified Process 1998-2010
- Extreme Programming 1999-Present
- Agile Software Development 2001-Present
- DevOps 2009-Present
- Continuous Delivery 2010-Present
Overview
Software process models are the frameworks a team uses to organize the making of software: what happens in what order, who does it, what gets written down, and how the work is checked and changed. The stakes are practical. A program of a few hundred lines can be built by one person in an afternoon, but a banking system or an air-traffic network takes years, many people, and constant revision. The process model is the answer to the question of how to keep such work from collapsing under its own complexity. The history of these models is a history of competing answers—each one a reaction to the failures of the last.
The software crisis and the first life-cycle models
Through the 1950s and early 1960s, most software was written ad hoc, often by the same people who ran the hardware. As systems grew, projects ran late, over budget, and unreliable. A 1968 NATO conference in Garmisch, Germany, gave the problem a name—the "software crisis"—and the term "software engineering" entered circulation. The first response was to borrow the discipline of large construction and manufacturing: define the stages of building a system and move through them in order.
The software development life cycle (SDLC) is the general idea that software passes through phases—requirements, design, implementation, testing, deployment, maintenance—and that managing the transitions between them is as important as the coding. The best-known concrete form is the Waterfall Model, usually credited to Winston Royce's 1970 paper "Managing the Development of Large Software Systems." Royce drew the phases as a cascade flowing downward, and the image stuck. It is worth noting that Royce himself warned the pure cascade was "risky and invites failure"; he recommended iterating back to earlier phases. The simplified version—finish each phase before starting the next, with no going back—became the standard prescription of the 1970s and 1980s, especially in defense and government contracting, where fixed requirements and milestone reviews suited the procurement process. Its appeal was control: each phase produced documents that could be reviewed and signed off, and progress could be measured against a plan.
Iteration and risk: the spiral and incremental approaches
Waterfall's weakness showed up on projects where requirements were uncertain or changed. By the time testing began, the design was frozen, and discovering a misunderstanding meant expensive rework. In the 1980s, a countercurrent grew: build the system in increments, and revisit earlier decisions.
Barry Boehm's Spiral Model, published in 1986 and refined in 1988, made risk the organizing principle12. The project proceeds in loops; each loop begins by identifying the riskiest remaining unknowns, then builds a prototype or partial product to resolve them, then plans the next loop. A team building a new transaction system might spend its first spiral proving that the database can handle the expected load before committing to a full design. The spiral combined the discipline of phased development with the flexibility of prototyping, and it introduced explicit risk analysis as a first-class activity1.
Around the same time, incremental and evolutionary delivery gained ground: ship a working subset, learn from it, extend it1. These ideas set the stage for the 1990s, when object-oriented methods and a new generation of process frameworks arrived1.
Process maturity and the Capability Maturity Model
A parallel strand asked not how to sequence work but how to improve an organization's process over time. The Capability Maturity Model (CMM), developed at the Software Engineering Institute at Carnegie Mellon University from the late 1980s (the first version appeared around 1991), rated an organization's process on five levels: initial, repeatable, defined, managed, and optimizing. The premise was that a chaotic process produces unpredictable results, while a measured, documented one can be improved. CMM assessments became a requirement for many defense contractors, and the model was later generalized into CMMI (Capability Maturity Model Integration). Its critics argued that heavy documentation could become an end in itself, but the underlying insight—that process quality can be measured and raised—shaped how large organizations thought about software for a decade.
The Rational Unified Process and use-case-driven development
In the late 1990s, Grady Booch, Ivar Jacobson, and James Rumbaugh—the "three amigos" behind the Unified Modeling Language—packaged their methods into the Rational Unified Process (RUP), commercialized by Rational Software. RUP organized development into four phases (inception, elaboration, construction, transition) and iterated within them, with use cases driving requirements and architecture. It was explicitly iterative and architecture-centric, and it came with extensive templates and roles. RUP's weight and formality made it popular in large enterprises, but its sheer volume of artifacts also made it a target for the lighter methods that followed.
Agile: a reaction and a movement
By the late 1990s, a cluster of lightweight methods had emerged—among them Kent Beck's Extreme Programming (XP), Scrum, Crystal, and feature-driven development3. XP, articulated by Beck around 1999, pushed practices to extremes: pair programming, test-first development, continuous integration, and short release cycles. Scrum, drawing on work by Jeff Sutherland and Ken Schwaber in the early 1990s, organized work into short "sprints" with a prioritized backlog and daily stand-up meetings.
In February 2001, seventeen of these practitioners met at a ski resort in Snowbird, Utah, and published the Agile Manifesto, valuing individuals and interactions over processes and tools, working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan. Agile did not reject process; it relocated it—into short iterations, continuous feedback, and self-organizing teams. Its supporters found it convincing because it matched how good developers actually worked on uncertain problems; its critics worried it could excuse poor planning or scale badly. Both concerns drove the next two decades of work.
From continuous delivery to DevOps
Agile focused on development; the operations side—deploying, running, and monitoring systems—remained a bottleneck. Continuous delivery, described in Jez Humble and David Farley's 2010 book of that name, extended the idea of short cycles to release: keep the software always in a deployable state, automate the build-test-release pipeline, and ship small changes frequently. Continuous integration (merging and testing code many times a day) and continuous deployment (automatically releasing passing builds) are its close relatives.
DevOps, a term popularized around 2009, named the collaboration between development and operations teams that continuous delivery required4. It combined cultural change (shared responsibility for running systems), automation (infrastructure as code, automated pipelines), and measurement (monitoring and feedback)4. The through-line from the 1970s is visible: each step shortened the loop between deciding to change something and learning whether the change worked.
Where the field stands
Today no single model dominates. Waterfall survives where requirements are genuinely fixed and contracts demand it; the spiral's risk-driven iteration lives on in modern incremental planning; CMMI persists in organizations that need formal process assessment. Agile in its Scrum and Kanban forms is the default in much of the industry, and continuous delivery and DevOps are standard practice for teams that ship frequently. The open questions are the old ones in new clothes: how to scale agile practices to very large, regulated systems; how to balance speed with safety and security; and how to measure whether a process actually helps, rather than merely being followed. The history suggests the answer will keep shifting as the systems themselves grow more complex.
References
- Software development process (Examples, History), Wikipedia
- Spiral model (History), Wikipedia
- Agile software development (History), Wikipedia
- DevOps (History, introduction), Wikipedia
The frameworks of Software Process Models
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1968-Present
Systems development life cycle
What stages does building software pass through?
- 1970-2000
- 1980-Present
- 1986-2005
- 1991-2010
Capability Maturity Model
How can an organization improve its process over time?
- 1995-Present
- 1998-2010
Rational Unified Process
How do we structure iterative, use-case-driven development?
- 1999-Present
- 2001-Present
Agile Software Development
How do we respond to change rather than freeze plans?
- 2009-Present
- 2010-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Waterfall Model grew out of Systems development life cycle
Winston Royce's 1970 paper presented the waterfall as a concrete realization of the life-cycle phases, drawing the stages as a downward cascade. The simplified no-iteration version became the standard prescription for managing the SDLC.
Carried by Winston Royce; Managing the Development of Large Software Systems (1970).
Incremental build model reacted against Waterfall Model
Incremental build arose as a response to waterfall's failure on projects with uncertain or changing requirements, where freezing design before testing caused expensive rework. It proposed shipping working subsets and revisiting earlier decisions instead of a single pass.
Spiral Model reacted against Waterfall Model
Barry Boehm's Spiral Model was framed against the pure cascade, which he saw as failing when requirements were uncertain. It kept phased development but replaced the single pass with risk-driven loops and prototyping.
Carried by Barry Boehm.
Spiral Model influenced by Incremental build model
The spiral's loops build partial products and prototypes, extending the incremental and evolutionary delivery ideas that had gained ground in the early 1980s. Boehm combined that iterative building with explicit risk analysis.
Carried by Barry Boehm.
Rational Unified Process influenced by Spiral Model
RUP's four phases with iteration inside them and its architecture-centric, risk-aware elaboration drew on the spiral's combination of phased discipline with iterative loops. The three amigos packaged iterative development into a commercial process framework.
Carried by Grady Booch; Ivar Jacobson; James Rumbaugh.
Agile Software Development influenced by Scrum
Scrum was one of the lightweight methods whose practitioners met at Snowbird and whose sprint-and-backlog practices fed the Agile Manifesto. Scrum's short iterations and self-organizing teams became central to the movement.
Carried by Ken Schwaber; Jeff Sutherland; Agile Manifesto (2001).
Extreme Programming reacted against Rational Unified Process
Extreme Programming was articulated as a lightweight alternative to heavy, artifact-laden processes like RUP. Beck pushed practices to extremes and cut the extensive templates and roles that made RUP a target for lighter methods.
Carried by Kent Beck.
Agile Software Development influenced by Extreme Programming
Kent Beck was among the seventeen signatories at Snowbird, and XP's practices—pair programming, test-first development, continuous integration, short releases—shaped the manifesto's values. XP became a flagship practice set of the agile movement.
Carried by Kent Beck; Agile Manifesto (2001).
DevOps influenced by Agile Software Development
DevOps extended agile's short feedback loops from development into operations, naming the collaboration between development and operations that frequent releases required. It combined cultural change, automation and monitoring to close the loop agile had left open.
Continuous Delivery influenced by Agile Software Development
Continuous delivery extended agile's short cycles to release, keeping software always deployable and automating the build-test-release pipeline. Humble and Farley built on the agile emphasis on frequent, small changes.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Capability Maturity Model influenced by Systems development life cycle
The Capability Maturity Model assessed and graded the process phases an organization followed, taking the life-cycle notion of defined stages and turning it into a scale of organizational maturity. It asked how well an organization ran its process rather than how to sequence a single project.
Carried by Software Engineering Institute.
Rational Unified Process influenced by Waterfall Model
RUP defined itself as explicitly iterative and architecture-centric, rejecting the single-pass cascade. It kept phase gates but placed them inside repeated cycles.
Carried by Rational Software.
Rational Unified Process influenced by Incremental build model
RUP's construction phase builds the system in increments within iterations, carrying forward the incremental build idea. Its use-case-driven iterations extend the practice of delivering working subsets.
Carried by Rational Software.
Agile Software Development influenced by Incremental build model
Agile's short iterations delivering working software carry forward the incremental build idea of shipping a working subset and extending it. The manifesto's valuing of working software over documentation restates that incremental emphasis.
Carried by Agile Manifesto (2001).
Continuous Delivery rival of DevOps
DevOps and continuous delivery emerged together around 2009–2010 to answer how to shorten the path from change to release. They overlapped heavily—automated pipelines, infrastructure as code, monitoring—and are often treated as complementary rather than sequential.
Carried by Jez Humble; David Farley.
Beyond the field
Where Software Process Models's ideas came from in other fields, and what they led to there: the strongest 12 of 59 links.
Systems development life cycle led to Secure Development Lifecycle in Systems Security
The secure development lifecycle is a direct refinement of the systems development life cycle: Microsoft's SDL inserted security activities such as threat modelling and security testing into each phase of the established SDLC.
Carried by Microsoft Security Development Lifecycle; Michael Howard; Steve Lipner.
Systems development life cycle led to Waterfall Model in Systems Lifecycle
The waterfall model was formulated as a concrete sequential realisation of the systems development life cycle, taking its phase decomposition of feasibility, design, implementation and maintenance from SDLC practice.
Carried by Winston W. Royce.
Systems development life cycle led to Waterfall Model in Software Engineering
The waterfall model is the sequential, document-driven form of the systems development life cycle; Royce's 1970 paper and later expositions presented the waterfall as the basic SDLC process for software.
Carried by Winston W. Royce; Managing the Development of Large Software Systems (1970).
Systems development life cycle led to Secure software development lifecycle in Cybersecurity
The secure development lifecycle is the general systems development life cycle with security activities inserted at each phase, a direct refinement of the older process model. Requirements, design, implementation, testing and maintenance stages were retained and augmented with threat modelling and security review.
Carried by Microsoft Security Development Lifecycle.
Waterfall Model provoked Spiral Model in Software Engineering
Boehm presented the spiral model explicitly as a risk-driven alternative to the waterfall model, which he criticised for treating development as a single sequential pass. The spiral's iterative cycles were defined against waterfall's linear phases.
Carried by Barry Boehm; A Spiral Model of Software Development and Enhancement (1986).
Waterfall Model grew out of Systems Development Life Cycle in Systems Analysis And Design
The waterfall model is the SDLC's sequential phases made explicit and prescriptive, with feedback loops added. Royce's 1970 paper formalised the phase sequence that the SDLC literature had already established.
Carried by Winston W. Royce; Managing the Development of Large Software Systems (1970).
Scrum influenced Agile software development in Systems Analysis And Design
Scrum, developed by Sutherland and Schwaber in the mid-1990s, supplied the sprint, backlog and daily-standup practices that the Agile Manifesto signatories adopted as core agile method. Scrum is one of the principal methods whose authors signed the 2001 manifesto and whose practices define agile software development.
Carried by Ken Schwaber; Jeff Sutherland.
Scrum influenced Agile software development in Systems Lifecycle
Scrum, presented by Schwaber and Beedle in 2001, was one of the principal methods whose signatories and practices shaped the Agile Manifesto and the agile movement. Agile development generalized and endorsed Scrum's iterative, self-organizing team model.
Carried by Ken Schwaber; Agile Software Development with Scrum (2001).
Scrum influenced Agile Software Development in Software Engineering
Scrum, developed by Sutherland and Schwaber in the 1990s, was one of the methods whose signatories wrote the Agile Manifesto, and its sprint-based process became the dominant agile framework. Agile software development is largely defined in practice by Scrum.
Carried by Ken Schwaber; Jeff Sutherland.
Rational Unified Process influenced by Object-Oriented Modeling in Model Based Systems Engineering
The Rational Unified Process was built on the Unified Modeling Language and object-oriented analysis and design, using UML models as its central artifacts. RUP's creators at Rational Software (Booch, Rumbaugh, Jacobson) developed it directly on top of object-oriented modeling notation and practice.
Carried by Grady Booch; Ivar Jacobson; James Rumbaugh.
Extreme Programming influenced Agile Software Development in Software Engineering
Extreme Programming's practices and values were central to the formation of agile software development, and Beck's book and the 2001 manifesto gathering carried them into the movement. Agile's engineering practices largely descend from XP.
Carried by Kent Beck; Extreme Programming Explained (1999).
Extreme Programming led to Agile Software Development in Software Engineering
Agile Software Development as a named movement grew out of Extreme Programming and other lightweight methods, crystallized in the 2001 Agile Manifesto which Beck and other XP practitioners signed. XP became one of the founding practices of the agile framework.
Carried by Agile Manifesto (2001); Kent Beck.

Software Process Models is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Software Process ModelsRelated fields
Fields its ideas are linked to
- Software Engineering 12 links
- Systems Lifecycle 9 links
- Project Management 8 links
- Systems Engineering 5 links
- Devops And Sre 4 links
- Software Evolution 4 links
- Systems Analysis And Design 3 links
- Systems Integration 2 links
- Data Science 1 link
- ML Systems 1 link
- Industrial Engineering 1 link
- Innovation Management 1 link
More in Software Engineering
- Computing Education
- Design Patterns
- Devops And Sre
- Formal Methods
- Open Source Software
- Requirements Engineering
- Software Architecture
- Software Engineering
- Software Evolution
- Software Testing
See where Software Process Models sits on the Map of Human Knowledge