A finished system built around one or more chips, such as a controller, a board-level product, an appliance or a server, from its requirements and the partitioning between hardware, software and firmware through virtual prototypes, board and enclosure design, emulation and FPGA prototypes for early software, prototype builds and system integration, design validation and certification to production release, field updates and end of support.
Start here: what it is, how the related terms differ, what this lifecycle covers and its phases in order, then the detail.
A system is finished equipment that does a job for its user: a controller, an appliance, a camera, a network switch, a server or an instrument. It is built around one or more chips, but it also needs boards, power, an enclosure, cooling, connectors, firmware, software and the approvals to be sold.
Most of a system's behaviour is decided long before anything is built, when its functions are split between hardware, firmware and software. A function placed in a custom chip is fast and efficient but fixed at tape-out; one placed in programmable logic can change later; one placed in software can change every week but may be too slow or use too much power.
A system is where chips meet their use. For a chip company it is the customer's equipment; for a system company it is the product itself, and the chips are parts it selects, buys or has designed.
These words are often used loosely. On this Hub they mean the following, from the smallest piece to the widest.
| Term | What it is | How it differs |
|---|---|---|
| Chip | The everyday word for an integrated circuit. | Informal: it can mean the die, the part or the product. In a system it is one part among many. |
| Module |
System development lifecycle: 12 stages, 15 gates of its own and 6 hand-offs to the Product lifecycle, from System Requirements & Use Cases to End of Life & End of Support.
12 stages, 15 gates of its own and 6 hand-offs to the Product lifecycle, 3 of the gates technical readiness reviews (TR). Each stop opens its stage; each sign opens its gate. Point at a stop or tab to it to read what the stage is for. What the codes mean
In collaboration with The Digital Electronics Blog (opens in a new tab)
A dashed sign with a TR tag is a technical readiness review gate.
An outlined sign with an arrow is a hand-off: the gate is owned by the Product lifecycle, where this lifecycle hands its work on.
In collaboration with The Digital Electronics Blog (opens in a new tab)
Deciding what the finished system has to do and for whom: the use cases and operating conditions, the functions, performance, power, size, cost and lifetime targets, the markets and the certifications they need, and the technology the system will depend on.
Concept approval gate, owned by the Product lifecycle (Concept approval)TR1: Technology feasibility gateTR1, technical readiness reviewSystem requirements baselined gate
An outlined sign with an arrow is a hand-off: the gate is owned by the Product lifecycle, where this lifecycle hands its work on.
Choosing how the system is built: its block structure, the chips, FPGAs and modules it uses, which functions go into custom silicon, programmable logic, firmware or software, the interfaces between them, and the security, power and thermal concepts, so that every team builds to the same split.
Architecture and partitioning approved gatePlan approved gate, owned by the Product lifecycle (Plan approval and development commit)
Building executable models of the system before its chips or boards exist, so software and firmware can start early and architecture choices can be checked against real workloads: functional models first, then models with enough timing to judge performance.
Designing the printed circuit boards, power delivery, connectors, enclosure, cooling and mechanical parts the chips sit in, from the board block diagram and power tree to schematics, layout, the bill of materials and the mechanical and thermal design, ready for the first prototype build.
Running the design at speed before the final hardware exists: the custom chip's design on an emulator or FPGA prototype, or the system's logic on development boards, so that firmware and software can be brought up and hardware and software verified together against the system's use cases.
Developing the firmware, board support, operating system, middleware and applications of the system on models, prototypes and early boards until every planned feature is in, with the security and update design that the system will ship with.
Building the first engineering prototypes, often called the engineering validation test (EVT) build, bringing up boards, chips, firmware and software together, fixing what fails and freezing the system design for the design validation build.
Proving the frozen design meets its requirements on units built close to production, often called the design validation test (DVT) build: functional, performance, power, thermal, environmental, reliability, software and security testing, with pre-compliance checks for certification.
System design freeze gateTR2, technical readiness reviewDesign validation complete gate
Getting the system approved for the markets it will be sold in: formal testing for electromagnetic compatibility, electrical safety, radio, environmental and market rules at accredited laboratories where required, the certificates and declarations of conformity, and the markings and documents that go with the product.
Certification tests passed gateCertificates and declarations issued gate
Proving the system can be built in volume on the production line, often called the production validation test (PVT) build, with production test, the approved vendor list and the production bill of materials in place, then releasing the system and its software for sale.
Production validation complete gateTR3, technical readiness reviewProduction release gate
Keeping the shipped system working and secure: field issue handling, software and firmware updates, security advisories, component changes and obsolescence, cost reductions and periodic reviews of the product's health against its plan.
Volume ramp gate, owned by the Product lifecycle (Volume ramp)Field update release gateLifecycle review gate, owned by the Product lifecycle (Lifecycle review)
Ending the system's sale and support in an orderly way: the discontinuance notice, last builds and last-time buys of parts, spares and repair support, the final software and security releases, and an archive that lets later questions still be answered.
Discontinuance notice gate, owned by the Product lifecycle (Discontinuance notice)End of support gate, owned by the Product lifecycle (End of support)
| One or more chips with other components on a small board, sold as one part.For example: A wireless module with its antenna. |
| Bought and placed like a part, which saves design and certification work. |
| Board | A printed circuit board carrying chips, modules, power and connectors. | Designed by the system team; a system may have one board or many. |
|---|
| Product | The part, or a set of parts, with datasheet, software, support, qualification, supply commitments and roadmap. | The offer a chip company manages; a system company's product is the system. |
|---|
| System | The customer's finished equipment, such as a phone or a vehicle controller. | Hardware, firmware, software and enclosure that are validated and certified together, on their own timescale. |
|---|
| Platform | A shared architecture, IP and software base from which several products are derived. | Usually not sold as such; many systems may be built on one platform. |
|---|
| Reference design | A proven circuit, layout and software showing how to use a part. | A starting point for a system's boards, not the system itself. |
|---|
| Virtual prototype | An executable model of the system that runs its software before the hardware exists. | Lets software start early; it is only as accurate as its models. |
|---|
The system lifecycle is the engineering path of one system, from its requirements to the end of its support: deciding what it must do and how its functions are split, designing its boards, enclosure, firmware and software, building and integrating prototypes, validating and certifying it, then releasing and supporting it in the field.
It runs inside the product lifecycle, which owns the business decisions: concept, plan approval, production release, lifecycle reviews and end of life. Beside it run the lifecycles of the chips inside it: the SoC lifecycle for a custom chip, the FPGA lifecycle for programmable logic and the firmware lifecycle for the software that ships with a chip.
Three kinds of work let software and hardware mature together instead of one after the other. Virtual prototypes run the software on models before any hardware exists. Emulation and FPGA prototypes run the real design at speed, so firmware and software can be brought up and verified with the hardware. Engineering, design and production validation builds then prove the system on real units.
A system lead or programme manager usually runs it, with the system architect owning the technical decisions. Its gates matter because each build and each certification is expensive to repeat: the design freeze and the validation builds exist to find problems while they can still be fixed.
A dotted underline opens the full definition in the glossary.
The full lifecycle detail, with its charts, flows, tables and every section, is for registered members. Registration is free and takes a minute. You come back to this page afterwards.
Credible sources, named for further reading. Standards are available from the body that publishes them.