What the embedded development life cycle is
The embedded development life cycle is the sequence of stages an embedded product passes through, from the first idea to the day it is retired. It covers both the hardware and the software, and it extends well beyond the point where the product first ships.
Many guides borrow the general software development life cycle (SDLC), which typically lists phases such as planning, requirements, design, development, testing, deployment and maintenance. Those phases still apply, and we explain them in what are the 7 phases of the SDLC. But embedded products add stages and constraints that pure software projects rarely face.
How it differs from a pure software life cycle
- Physical hardware takes time. A PCB revision can take weeks to fabricate and assemble. Firmware can’t be fully tested until boards exist.
- Hardware is hard to change. Once boards are manufactured, fixing a hardware mistake often means rework or a new revision.
- Supply chains matter. Component lead times and availability can delay a project or force a redesign.
- Certification may be required. Radio, electrical safety, electromagnetic compatibility and, in some sectors, functional safety approvals add formal stages.
- Manufacturing is part of the design. Products need programming procedures, production test and traceability.
- The field is hard to reach. Devices may be in remote locations or sealed enclosures, so updates must be planned carefully, or may be impossible.
- Lives are long. Industrial and automotive products may stay in service for many years, outliving their original components and toolchains.
The stages of the embedded system life cycle
Different companies use different names and groupings, but the following stages cover what most embedded products go through. They map closely onto the embedded system design flow, extended across the whole life of the product.
1. Concept and feasibility
Identify the need or opportunity, sketch a product concept, and check whether it can be built at an acceptable cost and risk. Quick proof-of-concept experiments on development boards are common here, to test the riskiest technical assumptions before committing serious money.
2. Requirements
Capture what the system must do and how well: functions, response times, power budget, operating environment, cost targets, size, regulatory requirements and expected service life. Good requirements are specific and testable. “Long battery life” is a wish; “at least 12 months on the specified battery at one reading per five minutes” is a requirement.
3. Architecture and system design
Define the system’s structure: the main hardware blocks, the processor, the software architecture, and the split of functions between hardware and software. This is where hardware-software co-design decisions are made. It is also the stage to choose the processor family, a step our guide on how to choose a microcontroller covers in detail.
4. Detailed hardware and software design
On the hardware side: schematics, component selection, PCB layout, power design and mechanical integration. On the software side: module design, driver interfaces, task structure or state machines, communication protocols, memory layout and the update mechanism. Some teams use model-based design at this stage, especially for control logic.
5. Implementation
Build it: fabricate and assemble prototype boards, and write the firmware. Code reviews, static analysis and unit tests usually run continuously during this stage rather than waiting until the end.
6. Integration
Bring hardware and firmware together on real boards, then integrate subsystems into the complete product. Integration is often where schedules slip, because it exposes mismatched assumptions about pins, timing, power sequencing and noise.
7. Verification and validation
Verification checks that the product was built as designed; validation checks that it meets the real needs of users in realistic conditions. Methods include unit, integration and system testing, hardware-in-the-loop testing, environmental testing and field trials. See testing and validating embedded software for detail.
8. Certification and compliance
Depending on the product and market, this can include electromagnetic compatibility testing, radio approvals, electrical safety and sector-specific standards such as ISO 26262 for automotive or IEC 62304 for medical device software. Certification requirements should be understood at the requirements stage, not discovered at the end, because they can affect architecture, documentation and testing throughout.
9. Manufacturing and deployment
Prepare for production: design test fixtures, define how firmware is programmed onto each unit, set up traceability of serial numbers and firmware versions, and ramp up volume. Then ship and install the product.
10. Maintenance, updates and support
After launch, the product needs bug fixes, security patches and sometimes new features. For connected devices, this usually means over-the-air (OTA) updates, which need a robust design: a bootloader that can recover from a failed update, signed firmware images, and a way to roll back. Support also covers repair, spare parts and diagnosing field failures.
11. Obsolescence and end of life
Components eventually go out of production. When a key part is discontinued, the team may need to buy a final stock, find a compatible substitute, or redesign the board, which can trigger retesting or recertification. Eventually, the product itself is retired, which may involve ending support, notifying customers and handling disposal responsibly.
Hardware build stages: prototypes, EVT, DVT and PVT
Many hardware companies, especially in consumer electronics, structure hardware development as a series of builds. The names vary between companies, but a common pattern is:
- Prototypes and proof of concept: rough builds, often hand-assembled or using development boards, to prove the idea works.
- EVT (engineering validation test): early boards close to the intended design, used to confirm that the electronics meet their functional requirements.
- DVT (design validation test): units with production-intent design and enclosure, used for full validation, environmental testing and certification.
- PVT (production validation test): units built on the real production line, to confirm that the manufacturing process can produce good units consistently.
Firmware matures alongside these builds. A common goal is for firmware to be feature-complete by DVT, so validation and certification test the real product.
Process models for embedded development
A process model describes how the stages are organised in time. No single model is correct for every project.
Waterfall
In a waterfall model, each stage is completed before the next begins. It is easy to plan and document, which suits some regulated projects. Its weakness is that problems found late, especially in integration, are expensive to fix.
V-model
The V-model pairs each design stage on the left side of a “V” with a matching test stage on the right: requirements with acceptance and system testing, architecture with integration testing, detailed design with unit testing. It emphasises traceability between requirements and tests, which is why it is widely used in safety-critical sectors such as automotive, aerospace and medical devices.
Iterative and agile approaches
Agile methods such as Scrum deliver working functionality in short iterations and adapt as requirements change. They work well for firmware, particularly application logic, user interfaces and connectivity. Applying them to hardware is harder, because each board revision takes weeks, but the mindset of building small, testing early and learning fast still helps.
Hybrid approaches in practice
Many embedded teams combine models: a staged, V-model-style structure for hardware and formal verification, with agile iterations for firmware inside each stage. Continuous integration, automated tests and frequent builds on real hardware help keep firmware quality high even when hardware moves more slowly.
The embedded software development process day to day
Within the larger life cycle, firmware development tends to follow a recognisable rhythm:
- Requirements are broken into tasks and traced to tests.
- Code is written against a hardware abstraction layer, so much of it can be unit-tested on a PC.
- Every change goes through version control, code review and an automated build.
- Static analysis tools and coding standards (such as MISRA C in many safety-related projects) catch classes of defects before testing.
- Unit tests run on the host; integration tests run on development boards or the target hardware, sometimes in a hardware-in-the-loop rig.
- Releases are versioned, with the exact source, toolchain and configuration recorded so any shipped firmware can be rebuilt.
Common life-cycle pitfalls
- Skipping requirements. Teams that jump straight to hardware often discover missing requirements during integration or certification.
- Underestimating integration. Schedules that assume hardware and firmware will “just work” together almost always slip.
- Leaving compliance to the end. Failing emissions testing late can force layout changes and another board revision.
- No update path. Shipping a connected product without a robust, secure update mechanism makes every bug permanent, or at least very expensive.
- Ignoring component lifecycle. Designing around a part that is near the end of its production life can force an early redesign.
- Poor configuration management. If you can’t rebuild the exact firmware that shipped, supporting field units becomes much harder.
Summary
The embedded system life cycle runs from concept and requirements through design, implementation, integration, verification, certification and manufacturing, and then continues for years with updates, support and eventual obsolescence. Its distinguishing features are physical hardware builds, certification, manufacturing, field updates and long service lives. Most teams combine a structured model such as the V-model with iterative firmware development, and the most common pitfalls come from treating integration, compliance and maintenance as afterthoughts.