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

still a working view ended · each leads to its entry below

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

  1. Systems engineering (introduction, Holistic view, Interdisciplinary field), Wikipedia
  2. Spiral model (introduction, History), Wikipedia
  3. V-model, Wikipedia
  4. Phase-gate process, Wikipedia
  5. Agile software development, Wikipedia
  6. DevOps (introduction, History), Wikipedia
  7. Model-based systems engineering, Wikipedia
  8. 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.

  1. 1970-Present

    Waterfall Model

    In what order should development phases proceed?

    Fly to its tower in Nousfarer

  2. 1980-Present

    V-Model

    How can each design level be matched to a test?

    Fly to its tower in Nousfarer

  3. 1985-Present

    Concurrent Engineering

    How can design and production be done at once?

    Fly to its tower in Nousfarer

  4. 1985-Present

    Phase-Gate Process

    When should a project be continued or killed?

    Fly to its tower in Nousfarer

  5. 1986-Present

    Spiral Model

    How should risk shape the order of development?

    Fly to its tower in Nousfarer

  6. 1990-2010

    Integrated Product and Process Development

    How can the whole lifecycle be considered from the start?

    Fly to its tower in Nousfarer

  7. 2000-Present

    Continuous Integration and Continuous Delivery

    How can code changes be built and tested automatically?

    Fly to its tower in Nousfarer

  8. 2000-Present

    Model-Based Systems Engineering

    How can system knowledge be held in one model?

    Fly to its tower in Nousfarer

  9. 2001-Present

    Agile software development

    How can teams respond to change while delivering working software?

    Fly to its tower in Nousfarer

  10. 2009-Present

    DevOps

    How can building and running a system be unified?

    Fly to its tower in Nousfarer

  11. 2010-Present

    Digital Twin

    How can a virtual model track a real asset's life?

    Fly to its tower in Nousfarer

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 ModelV-ModelConcurrent EngineeringPhase-Gate ProcessSpiral ModelIntegrated Product and Process Develo…Continuous Integration and Continuous…Model-Based Systems EngineeringAgile software developmentDevOpsDigital Twin

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Lifecycle

Related fields

Fields its ideas are linked to

More in Systems Engineering

See where Systems Lifecycle sits on the Map of Human Knowledge