The early stages (exploration, feasibility, technical validation) are the most uncertain and risky phases of an innovative project. This is where 80% of failures originate: vague requirements, unproven technology, unknown integration risks. R&D Early Stages offers an alternative: iterate rapidly, validate each advance through proofs of concept, and reduce uncertainty through controlled steps.
The majority of project failures take root in the early stages. Why?
Traditional approach: plan everything upfront, freeze specifications, launch design. Result: late discovery of problems, enormous rework costs, missed deadlines.
Agile approach: iterate rapidly, validate real progress within the project (not merely in project management), and reduce uncertainty through controlled steps. Each cycle provides concrete validation, each step answers a specific question.
In uncertain projects (disruptive innovation, technological risk-taking, multisector contexts), some developments will need to be halted or profoundly redirected before reaching completion. It is far better to discover this early than to waste months of work and miss opportunities.
Agile management fosters this adaptability: each cycle confronts hypotheses against real-world and market conditions. An early pivot becomes a strategic asset, not an admission of failure. Result: confidence for the remainder of the project, preserved resources, teams focused on the right priorities.
Two concepts often confused, yet complementary in R&D Early Stages:
Definition: reworking and refining the same thing, cycle after cycle.
Metaphor: like sculpting a statue. You start from a rough block, refine the contours, adjust the details, polish the surface.
R&D example: design a mechanism, test it, identify weaknesses, revise the design, retest. Each iteration improves the same subsystem until a conclusive demonstration is achieved.
Benefit: converge towards an optimised solution, validated through real-world use.
Definition: adding pieces progressively, extending the scope.
Metaphor: like building with bricks. You lay the foundations, then the walls, then the roof. Each step adds a layer.
R&D example: start with module A, then integrate module B, then add module C. Each cycle delivers a more complete version of the product.
Benefit: test integration progressively, detect incompatibilities early, deliver value incrementally.
In practice: R&D Early Stages combines both. You iterate to refine each subsystem, you increment to build the complete product. Result: technical convergence combined with controlled integration.
Feasibility demonstration is at the heart of R&D Early Stages during the early stages. How should it be organised?
Each cycle (2 to 4 weeks) delivers measurable progress:
No blind development. Before each cycle, the team formulates the hypotheses to validate:
The iteration is designed to provide answers. After testing, the team decides: validate, modify, or pivot.
You iterate on critical points (mechanism, component, interface), you increment by adding subsystems progressively. Each cycle reduces uncertainty and advances technical maturity on the TRL (Technology Readiness Level) scale: from TRL 1-2 (principle observed) towards TRL 4-5 (validation in representative environment). Beyond that, industrialisation takes over with a sequential process.
To structure these early stages, we recommend hybrid management: a Stage-Gate framework for governance (go/no-go at each milestone), Agile iterations for technical execution. The best of both worlds.
Launch your first feasibility sprint We guide you through your project
In consumer electronics and connected products, the development cycle is often described as EVT, DVT, PVT. These three stages structure the path from engineering concept to mass production. They map directly to the iterative approach described above.
| Stage | Full name | Purpose | Agile equivalent |
|---|---|---|---|
| EVT | Engineering Validation Test | Verify that the design works: critical functions, component selection, integration tests | Cycles 3-5 (functional proofs of concept, TRL 3-4) |
| DVT | Design Validation Test | Validate the complete product: mechanical, thermal, electrical, user testing, regulatory compliance | Cycles 6-8 (advanced demonstrations, TRL 4-5) |
| PVT | Production Validation Test | Confirm that the product can be manufactured at scale: yield, reliability, tooling qualification | Cycles 9+ (pre-series, industrialisation) |
| MP | Mass Production | Full-scale manufacturing | Sequential process (beyond agile scope) |
The traditional EVT-DVT-PVT sequence is linear: finish EVT, then start DVT, then PVT. This works when the design is stable. But for innovative products with high uncertainty, each stage can require multiple iterations. R&D Early Stages accelerates the process by running short validation cycles within each stage. Instead of one long EVT phase that ends with a go/no-go, you run 2-3 focused sprints that each validate a specific engineering question.
Result: fewer surprises at the EVT-to-DVT transition, fewer DVT builds needed, shorter overall time from concept to PVT.
Hybrid management: Stage-Gate + Agile | Understanding industrial agility
Each industrial prototype iteration costs time and money: fabrication, testing, analysis, modification. The goal is not to eliminate iterations but to make them more effective. How? By testing critical points as early as possible: numerical simulation before fabrication, sub-system interface validation from the first cycles, DFM (Design for Manufacturing) integration before the final prototype.
Documented result: teams that validate one technical hypothesis per cycle reduce prototype count by 30 to 50% before pre-production.
A reliable development schedule in R&D is not built on a detailed 12-month Gantt chart. It is built on validation milestones: each 2-4 week cycle confirms a technical step. The schedule advances on results, not estimates. Uncertainties are absorbed by the flexibility of subsequent cycles, not by an overall schedule slip.
A feasibility sprint in R&D is a 2-4 week iteration designed to answer a specific technical question. Structure: at the start of the sprint, the team formulates the hypothesis to validate (does this material withstand thermal constraints? do these modules integrate properly?). During the sprint, it designs, builds and tests. At the end of the sprint, it presents the result (test report, functional mock-up, proof of concept) and decides: validate, modify or pivot. Each feasibility sprint reduces an identified risk.
Uncertainty in the exploration phase is managed through short iterations that confront each hypothesis against field reality. Instead of planning everything upfront (predictive approach), you validate progressively: cycles 1-2 for exploration mock-ups, cycles 3-5 for functional proofs of concept, cycles 6+ for advanced demonstrators. Each iteration answers a question, each answer guides the next. An early pivot becomes a strategic asset, not an admission of failure.
A proof of concept sprint (iterative POC) delivers measurable progress, not necessarily a finished object. Valid deliverables: test report demonstrating a performance, technical risk assessment, subsystem interface validation, material choice supported by data. The important thing is demonstrable project progress. Iterative POCs follow a maturity progression: mock-ups (TRL 2-3), functional prototypes (TRL 3-4), advanced demonstrators (TRL 4-5).
TRL (Technology Readiness Level) measures technological maturity from TRL 1 (principle observed) to TRL 9 (qualified system). Agility accelerates progression between TRL 1 and TRL 4-5 through feasibility sprints: you iterate on critical points (mechanism, component, interface) and increment by adding subsystems progressively. Beyond TRL 5, industrialisation follows a sequential process. Agile Stage-Gate structures this transition: gates correspond to TRL milestones, sprints execute between each gate.
A sprint in early R&D phase typically lasts 2 to 4 weeks, depending on the complexity of the deliverable to produce. Short sprints (2 weeks) for software validations or simulations. Longer sprints (4 weeks) for prototypes requiring manufacturing and testing. The overall early stage phase lasts 3 to 8 months, often shorter than a traditional approach because problems are detected and resolved as they arise.
Rarely. A classical feasibility study produces a report frozen at a point in time, based on untested assumptions. For an innovative project, uncertainty evolves constantly. The iterative approach transforms feasibility into a continuous process: each sprint provides new data, each POC reduces a specific risk. The result is feasibility demonstrated through evidence of progress, not merely declared in a document.
Redesign loops occur when integration, manufacturability or performance issues are discovered too late. The agile solution: test early and often. Each sprint validates a critical aspect (mechanical interface, thermal performance, assembly). Design for Manufacturing (DFM) is integrated from the first sprints, not at the end of the project. Result: problems are detected when the cost of change is still low (CAD, simulation) instead of being discovered on the prototype or worse, during industrialisation.
This is the cost-of-change curve: modifying a specification during the design phase costs 1x, during prototyping 10x, during industrialisation 100x, and after launch 1000x. In a sequential approach, integration problems are often discovered during validation, when tooling has been ordered and suppliers are committed. Hardware Agility reduces this risk by validating each technical hypothesis through short iterations in the upstream phases, when the cost of change is still manageable.
A complex project (multi-technology, multi-supplier, regulatory requirements) cannot be planned in one go. Break it into 2-4 week cycles with a clear technical objective per cycle. The first cycle validates the highest-risk item (does the material hold? does the interface work?). Subsequent cycles add complexity progressively. The overall schedule exists, but priorities are adjusted each cycle based on actual results. Supplier lead times are anticipated 2-3 cycles ahead.
Integration problems (mechanical interfaces, electromagnetic compatibility, assembly tolerances) only reveal themselves during assembly and testing. To catch them early: test sub-system integration from the first cycles, not only on the final prototype. Each cycle integrates an additional level of complexity. Result: incompatibilities are discovered when it is still simple and inexpensive to modify the design.
EVT (Engineering Validation Test), DVT (Design Validation Test) and PVT (Production Validation Test) are the three stages of hardware product validation before mass production (MP). EVT verifies that the engineering design works: critical functions, component selection, integration. DVT validates the complete product: mechanical, thermal, electrical performance, user testing, regulatory compliance. PVT confirms manufacturability at scale: yield, reliability, tooling qualification. This sequence is standard in consumer electronics, IoT and connected products.
In a traditional approach, EVT, DVT and PVT are long sequential phases with a single go/no-go at the end of each. Agile Hardware runs short validation cycles (2-4 weeks) within each phase. Instead of one monolithic EVT, you run 2-3 focused sprints that each answer a specific engineering question. Result: problems surface earlier within EVT, fewer DVT builds are needed, and the overall path from concept to PVT is shorter. The Stage-Gate structure remains for governance, but execution is iterative.
Before EVT: the exploration phase covers concept development, feasibility studies and early proofs of concept (POC). This is where agile iterations have the highest impact, because uncertainty is greatest. Some organisations add an NPI (New Product Introduction) phase that spans from concept to mass production. After PVT: MP (Mass Production) begins. The product is manufactured at full scale. Post-MP, sustaining engineering handles quality improvements and cost reductions.
Let's discuss your Agile challenges - no commitment