- Atlas
- Engineering
- Systems Lifecycle
Systems Lifecycle
Systems lifecycle is the part of systems engineering that treats a system not as a thing but as a span of time.
11 frameworks, from 1970 to today · Systems Engineering · Engineering
- Waterfall Model 1970-Present
- V-Model 1980-Present
- Concurrent Engineering 1985-Present
- Phase-Gate Process 1985-Present
- Spiral Model 1986-Present
- Integrated Product and Process Development 1990-2010
- Continuous Integration and Continuous Delivery 2000-Present
- Model-Based Systems Engineering 2000-Present
- Agile software development 2001-Present
- DevOps 2009-Present
- Digital Twin 2010-Present
Overview
Systems lifecycle is the part of systems engineering that treats a system not as a thing but as a span of time1. Its practitioners ask how a complex product—an aircraft, a power plant, a telephone network, a hospital's records system—should be conceived, designed, built, tested, fielded, maintained, and finally retired, and how the work at each stage should be planned, funded, reviewed, and handed on to the next1. The stakes are practical: most of a system's total cost is committed early and spent late, and most of its failures trace back to decisions made long before anything was built. The history of the subfield is therefore a history of models—formal pictures of how a project should move through time—and of a long argument about whether such pictures should be sequential, iterative, concurrent, or continuous.
Sequential roots: the waterfall and its discontents
The oldest and most influential picture is the waterfall model: requirements, then design, then implementation, then testing, then operation, each phase completed before the next begins, with review gates between them. The image is often credited to a 1970 paper by Winston Royce, but Royce's paper, "Managing the Development of Large Software Systems," actually argued that the pure sequential form is risky and proposed iterating back to earlier phases. The model nonetheless took hold because it matched how large hardware programs—especially in aerospace and defense—were already being run under government procurement rules, where a contract specifies requirements up front and pays for defined milestones. Its appeal was accountability: at any moment you could say which phase you were in and what had been signed off.
The waterfall's weakness became clear as software grew. Requirements discovered late, or changed by the customer, forced expensive rework, and testing at the end revealed problems that had been baked in at the start. The response was to make the lifecycle explicitly iterative.
Iteration and risk: the spiral model
Barry Boehm's spiral model, published in 1986, reorganized the lifecycle as a series of loops2. Each loop begins with determining objectives and constraints, then identifies and evaluates alternatives, then develops and verifies the current increment, and finally plans the next cycle. The distinctive move was to make risk the organizing principle: each loop is sized and shaped by what is most uncertain or dangerous, and the spiral can be entered at any point. Boehm's model was developed in the context of large software and defense projects, and it gave project managers a vocabulary for talking about risk-driven iteration rather than treating iteration as a failure of discipline. It remains a reference point for any lifecycle that wants to be both planned and adaptive.
Concurrency and the V: designing the whole life at once
A parallel line of work attacked the sequential model from the hardware side. Concurrent engineering (also called simultaneous engineering) emerged in the 1980s, especially in Japanese and then American manufacturing, as the practice of designing a product and its manufacturing, support, and disposal processes at the same time rather than in sequence. The classic illustration is the automobile: if the people who will build and service a car are in the room while it is being designed, they can eliminate parts and steps that would otherwise be discovered as costly problems later. The idea was formalized in the United States through Integrated Product and Process Development (IPPD), a set of principles promoted in the 1990s, particularly in defense acquisition, that called for integrated product teams and for considering the full lifecycle—production, support, training, disposal—from the outset.
The V-model gave this thinking a memorable shape3. Instead of a straight line, the lifecycle is drawn as a V: the left side descends through requirements and design, the bottom is implementation, and the right side ascends through integration and testing, with each test level corresponding to a design level on the left. The point is that verification is planned from the beginning—each requirement written on the way down has a matching test on the way up3. The V-model is often associated with German engineering practice and with safety-critical domains such as automotive and medical devices, and it is frequently misread as a waterfall; in practice it is a framework for traceability, not a ban on iteration.
Gates and phases: the phase-gate process
Alongside these technical models grew a management model. The phase-gate process (also called stage-gate) divides a development effort into discrete phases separated by decision gates, at which a review committee decides whether to continue, redirect, or kill the project4. It was developed most prominently by Robert Cooper in the 1980s for product development, and it spread widely into industrial and pharmaceutical R&D. Its virtue is portfolio discipline: it forces an organization to decide, repeatedly and explicitly, whether a project still deserves resources. Its vice, critics argued, is that gates can become bureaucratic checkpoints that reward paperwork over learning, and that a project killed at a gate may have been worth saving.
Agile and the shift to continuous flow
The 1990s brought a reaction against plan-driven lifecycles in software. Agile development, crystallized in the 2001 Agile Manifesto, favored working software over comprehensive documentation, customer collaboration over contract negotiation, and responding to change over following a plan5. Its lifecycle form is the short iteration—typically a few weeks—with a working increment at the end of each. Agile did not abolish lifecycle thinking; it changed its unit. Instead of one long sequence, the lifecycle became a repeating cycle of planning, building, reviewing, and adapting, with the customer in the loop.
The same decade saw the rise of continuous integration and continuous delivery (CI/CD), practices in which developers merge code frequently and automated pipelines build, test, and prepare releases automatically. CI/CD made the lifecycle partly a property of tooling: the "phases" became automated stages in a pipeline that runs every time code changes. This was a profound shift in what a lifecycle model is—less a document describing phases than a machine that enforces them.
DevOps and the blurring of build and run
DevOps, emerging around 2009, extended this logic across the boundary between development and operations6. The traditional lifecycle treated "operation" as the long tail after delivery; DevOps argued that the people who run a system should be involved in building it, and that deployment and monitoring should be automated and continuous. The lifecycle became a loop rather than a line: operate, observe, feed back, change. This closed the gap that the waterfall had opened between making a system and living with it.
Models, twins, and the digital lifecycle
The most recent turn is toward representing the lifecycle in software. Model-Based Systems Engineering (MBSE) replaces document-centric specifications with formal models—diagrams and data structures that can be queried, simulated, and traced—so that requirements, design, and verification are linked in one coherent representation7. The digital twin, a term that gained currency in the 2010s, goes further: a continuously updated virtual model of a specific physical asset, fed by sensor data, used to predict behavior, schedule maintenance, and support decisions across the asset's life8. Together these developments make the lifecycle itself an object of engineering—something that can be modeled, simulated, and optimized rather than merely managed.
The present
Today the field is plural. Plan-driven lifecycles—waterfall, V-model, phase-gate—remain standard in regulated and safety-critical domains, where traceability and formal review are required. Iterative and agile approaches dominate software and increasingly inform hardware. Concurrent engineering and IPPD principles are embedded in how integrated product teams are organized. CI/CD and DevOps have made continuous delivery and operation the norm in software-intensive systems. MBSE and digital twins are pulling the whole lifecycle toward a model-centered, data-rich practice in which the boundary between design, operation, and feedback is increasingly porous78.
The open questions are the old ones in new clothes: how to plan when change is certain, how to keep a model honest when the system it represents keeps changing, and how to decide, at each gate or iteration, whether to continue. The history of systems lifecycle is the record of successive answers to those questions, each one a picture of time imposed on the messy work of building things that last.
References
- Systems engineering (introduction, Holistic view, Interdisciplinary field), Wikipedia
- Spiral model (introduction, History), Wikipedia
- V-model, Wikipedia
- Phase-gate process, Wikipedia
- Agile software development, Wikipedia
- DevOps (introduction, History), Wikipedia
- Model-based systems engineering, Wikipedia
- Digital twin (introduction, History), Wikipedia
The frameworks of Systems Lifecycle
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1970-Present
- 1980-Present
- 1985-Present
- 1985-Present
- 1986-Present
- 1990-2010
Integrated Product and Process Development
How can the whole lifecycle be considered from the start?
- 2000-Present
Continuous Integration and Continuous Delivery
How can code changes be built and tested automatically?
- 2000-Present
Model-Based Systems Engineering
How can system knowledge be held in one model?
- 2001-Present
Agile software development
How can teams respond to change while delivering working software?
- 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.
Spiral Model reacted against Waterfall Model
Boehm's spiral model was framed explicitly against the pure sequential lifecycle, arguing that a single pass through requirements-to-testing ignores risk. It reorganized the same phases into repeated loops sized by risk, defining itself as the iterative answer to the waterfall's weakness.
Carried by Barry Boehm.
Agile software development reacted against Waterfall Model
Agile development defined itself against plan-driven, document-heavy lifecycles of the waterfall type, valuing working software and response to change over following a fixed plan. The Agile Manifesto's contrast between comprehensive documentation and working software is a direct rejection of the sequential model's assumptions.
Carried by Agile Manifesto (2001).
Integrated Product and Process Development grew out of Concurrent Engineering
Integrated Product and Process Development formalized concurrent engineering principles for US defense acquisition, turning simultaneous design of product and process into integrated product teams and full-lifecycle considerations. IPPD is the institutional codification of the concurrent engineering idea.
DevOps grew out of Continuous Integration and Continuous Delivery
DevOps extended continuous integration and delivery across the development-operations boundary, adding automated deployment and monitoring to the CI/CD pipeline. It grew directly out of CI/CD practice, treating operations as a further stage of the same continuous flow.
Digital Twin grew out of Model-Based Systems Engineering
The digital twin extends model-based systems engineering from design-time models to a continuously updated virtual counterpart of a specific operating asset, fed by sensor data. It takes MBSE's formal system model and keeps it alive through operation, making the model a running artifact rather than a design document.
V-Model grew out of Waterfall Model
The V-model took the waterfall's sequence of requirements, design, implementation and testing and bent it so that each design level is paired with a matching verification level. It kept the phase-by-phase discipline but made test planning a counterpart to requirements, a direct refinement of the sequential picture.
Phase-Gate Process grew out of Waterfall Model
The phase-gate process took the waterfall's discrete phases and review points and turned them into management decision gates for product development portfolios. Cooper's stage-gate model kept the sequential phase structure but made the gate a go/kill decision rather than a technical sign-off.
Carried by Robert Cooper.
Model-Based Systems Engineering reacted against Waterfall Model
Model-based systems engineering arose as an alternative to the document-centric specifications that the waterfall tradition produced, replacing paper requirements documents with linked formal models. It defined itself against document-driven phase reviews while keeping the goal of traceability from requirements to verification.
Agile software development influenced by Spiral Model
Agile's short, risk-driven iterations echo the spiral model's repeated loops, and several Agile pioneers drew on Boehm's risk-based iteration when arguing for adaptive planning. The spiral supplied a vocabulary for planned iteration that Agile adopted in a lighter, customer-facing form.
Carried by Barry Boehm.
Continuous Integration and Continuous Delivery influenced by Agile software development
Continuous integration and delivery grew in the same software culture that produced Agile, taking its short-iteration, working-increment ethos and automating it into build-and-test pipelines. CI/CD made the Agile preference for frequent, small increments a property of tooling.
DevOps influenced by Agile software development
DevOps carried Agile's collaborative, feedback-driven ethos into the relationship between developers and operators, replacing handoff with shared responsibility. The Agile emphasis on cross-functional teams and rapid feedback is visible in DevOps's call to break down the build/run wall.
Model-Based Systems Engineering influenced by V-Model
MBSE's emphasis on tracing each requirement to a verification artifact formalizes the V-model's pairing of design levels with test levels in a machine-queryable model. The V-model's traceability logic is carried into model form.
Beyond the field
Where Systems Lifecycle's ideas came from in other fields, and what they led to there: the strongest 12 of 42 links.
Waterfall Model grew out of Systems Development Life Cycle in Systems Analysis And Design
The waterfall model grew directly out of the systems development life cycle taught in systems analysis and design, adopting its ordered analysis-design-implementation phases as a strict sequence.
Waterfall Model grew out of Systems development life cycle in Software Process Models
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.
Continuous Integration and Continuous Delivery influenced DevOps in Devops And Sre
Continuous integration and continuous delivery provided the automation pipeline, deployment tooling and 'delivery as a repeatable process' concept that DevOps adopted as its technical core. DevOps extended CI/CD from the build-and-release stage to the whole development-operations lifecycle.
Carried by Jez Humble; David Farley; Continuous Delivery (2010).
Model-Based Systems Engineering influenced Model-Based Integration and Digital Twins in Systems Integration
Model-based systems engineering supplied the modelling formalisms and SysML-based practice that digital-twin frameworks adopt to model a system's structure, behaviour and lifecycle. Digital twins extend MBSE from design-time models to continuously updated operational models fed by sensor data.
Model-Based Systems Engineering led to Digital Engineering in Systems Engineering
Digital Engineering grew directly out of Model-Based Systems Engineering, extending model-centric practice to authoritative digital representations across the lifecycle. MBSE supplied the modelling languages and processes that Digital Engineering broadened.
Model-Based Systems Engineering influenced by Object-Oriented Modeling in Model Based Systems Engineering
Object-oriented modeling, culminating in the UML standardization of 1997, provided the notation and modeling concepts on which SysML and hence MBSE were built. SysML was defined as a UML profile, so MBSE's language descends directly from OO modeling.
Carried by UML (1997); Grady Booch; Ivar Jacobson.
Model-Based Systems Engineering influenced Digital engineering and the digital thread in Model Based Systems Engineering
Digital engineering and the digital thread build directly on lifecycle MBSE, treating the system model as the authoritative source across the lifecycle. MBSE's model-centric practice is the foundation the digital thread extends.
Carried by INCOSE; DoD Digital Engineering Strategy (2018).
Agile software development influenced by Scrum in Software Process Models
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).
DevOps influenced by Continuous delivery in Devops And Sre
Continuous delivery, articulated by Humble and Farley in 2010 and rooted in earlier CI practice, supplied DevOps with its central technical mechanism: the automated deployment pipeline. DevOps adopted continuous delivery as the concrete practice realizing its development-operations integration.
Carried by Jez Humble; Continuous Delivery (2010).
DevOps led to MLOps in ML Systems
MLOps grew directly out of DevOps, applying its principles of continuous integration, continuous delivery and automated monitoring to machine learning pipelines. The later framework extended DevOps practices to cover data and model versioning and retraining.
DevOps led to MLOps in Data Science
MLOps grew directly out of DevOps practice, extending continuous integration, delivery and monitoring from software to machine-learning pipelines and models.
Waterfall Model influenced Phase-gate process in Innovation Management
Systems lifecycle waterfall practice supplied the phased, gated structure that Cooper adapted for commercial product development in stage-gate. The engineering lifecycle stages map onto Cooper's stages and gates.
Carried by Robert G. Cooper.

Systems Lifecycle 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 Systems LifecycleRelated fields
Fields its ideas are linked to
- Software Process Models 9 links
- Systems Integration 4 links
- Devops And Sre 3 links
- Software Engineering 3 links
- Software Evolution 3 links
- Model Based Systems Engineering 3 links
- Construction Management 2 links
- ML Systems 2 links
- Systems Analysis And Design 2 links
- Software Security 2 links
- Systems Engineering 2 links
- Digital Design Theory 1 link
More in Systems Engineering
- Decision And Risk Analysis
- Model Based Systems Engineering
- System Safety
- Systems Architecture
- Systems Engineering
- Systems Integration
- Systems Verification
See where Systems Lifecycle sits on the Map of Human Knowledge