Most people instinctively understand why making changes to a house’s design is cheap on paper, but painfully expensive once it’s built. That same logic applies directly to the NPI process (New Product Introduction) used for innovative electromechanical products.
As you move through the product development process stages, you make increasingly irreversible decisions. And every stage adds more dependencies: tooling, suppliers, validation, and production systems. The result? The cost of fixing problems grows exponentially.
The visual above captures it simply: the same issue can exist at any stage of the NPI process, but the cost, effort, and disruption of the issue multiply as you move forward.
What Is the NPI Process?
The NPI process (New Product Introduction) is the structured path that takes a product from concept to mass production.
In hardware, it typically includes:
- Feasibility study
- Prototyping
- Engineering Validation (EVT)
- Design Validation (DVT)
- Pre-Production / Production Validation (PVT)
- Mass Production
Each phase exists to validate something different: design feasibility, performance, manufacturability, and production readiness.
And, importantly, each phase increases the cost of change.
How is the NPI process like building a house?
Each stage of the NPI process has a clear equivalent in housebuilding, and the same rule applies: the later you are, the harder it is to make changes.
Prototyping: Cheap Changes, Fast Learning
At the early design stage of the NPI process, you’re working with concepts, mockups, and early builds.
This is the equivalent of drawing blueprints.
You can:
- Change architecture
- Test ideas quickly
- Iterate without major cost
There’s no tooling yet. No supply chain commitments. No locked design.
This is also where design for manufacturing (DFM) thinking should begin. Catching issues here, before validation, can save months later.
The key idea: early design work is where you buy information at the lowest cost.
Engineering Validation (EVT): Systems Start to Lock In
During Engineering Validation Testing (EVT), your product becomes a real system.
This is like framing a house and installing wiring and plumbing.
Now:
- Mechanical, electrical, and firmware systems interact
- Interfaces are tested
- Early manufacturing constraints appear
Changes are still possible, but no longer trivial.
A small design change can ripple across:
- CAD files
- BOMs
- Test plans
- Cross-functional teams
Resulting in a lot of work!
This is where many teams underestimate the true cost of engineering changes.
Design Validation (DVT): Where Costs Escalate
At the Design Validation Testing (DVT) stage, the product looks finished.
This is where teams often assume they’re “almost done.”
But in reality, this is where the risk of late design changes becomes serious.
Fixing problems now may require:
- Rebuilding units
- Modifying tooling
- Repeating validation tests
- Delaying schedules
In housebuilding terms, this is like ripping out cabinets or redoing installed fixtures.
The dangerous mindset here is: “We’ll fix it later.” That decision becomes expensive very quickly.
Pre-Production (PVT): Manufacturing Readiness
Production Validation Testing (PVT) is about proving that the product can be manufactured consistently.
This is no longer just about the design, it’s about the manufacturing process/es.
You’re validating:
- Production lines
- Work instructions
- Test fixtures
- Quality control processes
- Supplier readiness
A design issue discovered here doesn’t stay isolated; it affects the entire production system.
This is where manufacturing readiness validation becomes critical, and late-stage issues become operational problems.
Mass Production: When Problems Scale
Once you reach mass production, every issue scales with volume.
At this point, problems lead to:
- Production delays
- Rework or scrap
- Inventory issues
- Potential field failures
This is no longer just part of the product development lifecycle; it’s a business risk.
Fixing issues now may involve:
- Halting production
- Reworking shipped units
- Managing customer impact
The cost of late changes is no longer linear; it multiplies.
Why Are Late Design Changes So Expensive?
The key insight behind the NPI process is simple:
It’s not that problems get harder to fix. It’s that they become entangled with everything else you’ve already built.
This is because, when it comes to production, the cost is in tooling revisions, validation or certification testing that has to be done several times, a lot of rework, materials that were purchased but have to be scrapped, staying at the factory for much longer than planned, etc.
Late-stage changes require:
- Undoing completed work
- Rebuilding components
- Revalidating systems
- Coordinating across teams
- Absorbing delays
This is why product development risk management is really about timing.
Conclusion
The NPI process stages help us to find problems when they are still cheap to fix.
The house analogy makes it obvious:
- Early stages = flexible decisions
- Late stages = expensive consequences
Or more simply:
You can redraw it now, or tear it out later with a hammer and crowbar.
That’s the real trade-off in every new product development process.
