The prototype development process is a gated sequence that turns an idea into a validated, production-ready design: requirements, concept and design, first prototype, test and iterate, freeze, and handoff. Each step produces a deliverable, and the program advances only when it exists. This page is the execution guide; the definition and types of prototypes are covered in the What Is a Prototype guide, and the rapid prototyping process selection is covered in the Rapid Prototyping Process Guide.
Step 1: Define the Requirements
The process starts with the requirements, not the design. What must the product do, in what environment, at what cost, and under what constraints? The requirements list, function, performance, environment, and schedule, is the reference for every later decision, and it prevents the design from drifting toward what is easy instead of what is needed.
The requirements should include the validation criteria: how the prototype will prove the design. A requirement without a test is a hope, and the test plan belongs with the requirement. The prototype program is defined by what it must prove, and the requirements list is the contract.
Step 2: Concept and Design
The concept step explores the approaches and selects the direction. The design step turns the concept into geometry: the CAD model, the material selection, and the critical features. The design should be reviewed for manufacturability before the first prototype is ordered, because the DFM review is cheapest when the geometry is still moving.
The deliverable of this step is a design that can be prototyped: a model with the critical features marked, the materials named, and the tolerances assigned. A design that cannot be manufactured cannot be validated, so the DFM review is part of the design step, not a surprise at quoting.
Step 3: Build the First Prototype
The first prototype is built to answer the first question. The process, printed, machined, cast, or fabricated, is chosen by the question and the stage, and the prototype should be as simple as the question allows. A geometry question needs a printed part; a performance question needs a machined part in production material.
The first prototype produces the first data and the first surprises. The build reveals the features that were wrong in CAD, the tolerances that were optimistic, and the assembly steps that do not work, and the findings become the input to the next iteration.
Step 4: Test and Iterate
The test step checks the prototype against the requirements, and the iterate step fixes what failed. The loop, build, test, fix, repeat, is where the design matures, and the number of iterations follows the risk and the stage: cheap iterations early, expensive builds late.
The iteration should be recorded. Each version, the change, the test result, and the decision, becomes the design history, and the history transfers to production. A program that iterates without records rediscover the changes at first article, and the schedule pays for it.
| Step | Deliverable |
|---|---|
| Requirements | Requirements and test plan |
| Concept and design | CAD, materials, critical features |
| First prototype | A part that answers the first question |
| Test and iterate | Data, findings, and a design history |
| Freeze | A locked design with a complete drawing |
| Handoff | Validation data and the production specification |
Step 5: Freeze the Design
The freeze is the moment the geometry, materials, and finish stop changing. The freeze should happen after the functional data exists, and before the tooling is committed, because a change after tooling costs mold work and revalidation. The freeze deliverable is a complete drawing: datums, tolerances, materials, and finish, with revision control.
The freeze is a discipline, not a date. The design is frozen when the questions are answered and the changes are no longer learning, and the program should hold the line against changes that add cost without data. The change control that starts at the freeze protects the rest of the process.
Step 6: Hand Off to Production
The handoff transfers the validated design and its data to the production process. The production specification includes the drawing, the materials, the tolerances, the inspection plan, and the acceptance criteria, and the validation data, tolerances actually held and failure modes found, feeds the spec. The production first article is inspected against the spec, and the handoff is complete when the production process produces a part that meets it.
The handoff also transfers the supplier relationship. The production supplier inherits the design history, the DFM feedback, and the inspection points, and the communication and change control tested in the prototype phase carry into production. The handoff is the last step of the prototype process and the first step of production.
Budgeting the Prototype Process
The prototype budget should follow the risk curve, not a fixed percentage. High-risk stages, the concept and the functional validation, deserve the budget because the changes are cheap there; low-risk stages need less, and the tooling nodes dominate the final budget. The plan should allocate the budget by stage and review the allocation at each gate.
The budget also covers the invisible work: the DFM reviews, the testing, the records, and the iteration that does not produce a physical part. A prototype budget that pays only for parts misses the process, and the process is where the learning happens. The plan should name the full cost of each stage, parts, reviews, tests, and records.
Common Mistakes
- Skipping the requirements. A prototype without a test plan produces data without purpose.
- Ordering the process before the question. Printing a part that needs machining data wastes both time and trust.
- Iterating without records. The design history is the asset that transfers to production.
- Freezing too late. Every change after tooling costs mold work and revalidation.
- Handing off the file, not the data. The production supplier needs the tolerances, the failure modes, and the inspection points, not just the geometry.
The Tools That Support the Process
The prototype process runs on a few standard tools. The requirements document is the contract; the DFM review is the manufacturability check; the test plan is the validation definition; the design history, revision log, and change control are the records; and the gate review is the decision point. The tools are simple, and the discipline is using them every stage.
The same tools carry into production. The requirements, the test plan, and the change control that ran the prototype are the foundation of the production quality system, so the prototype phase is where the production discipline starts. The program that treats the prototype tools as temporary misses the point: they are the production system in embryo.
The gate review is the discipline that makes the process work: each stage presents its evidence, the questions are closed or carried forward, and the next stage starts with a clear scope. The gate is not a meeting; it is the control point that keeps the program from drifting.
Conclusion
The prototype development process is a gated sequence: requirements, concept and design, first prototype, test and iterate, freeze, and handoff. Each step produces a deliverable, and the gates protect the schedule and the budget. A rapid prototyping partner that supports the loop with DFM feedback, records, and production handoff is the one that carries the design from idea to validation without losing the history.
FAQs
What are the steps in prototype development?
Define requirements, design the concept, build the first prototype, test and iterate, freeze the design, and hand off to production. Each step has a deliverable, and the program advances only when the deliverable exists.
What is a design freeze and when does it happen?
The freeze is the point where geometry, materials, and finish stop changing, and it happens after the functional data exists and before tooling is committed. The deliverable is a complete drawing with datums, tolerances, and revision control, and from the freeze on, changes are change orders, not iterations.
How do I budget a prototype program?
Allocate the budget by risk curve: high-risk stages, concept and functional validation, deserve the budget because the changes are cheap there, and the tooling nodes dominate the final budget. The plan should also cover the invisible work, DFM reviews, testing, and records, because the learning is in the process, not only the parts.
What is a gate review?
The gate review is the control point where each stage presents its evidence, the questions are closed or carried forward, and the next stage starts with a clear scope. It is a data decision, not a meeting, and it is what keeps the program from drifting.
What documents should a prototype program produce?
The requirements and test plan, the CAD with revisions, the DFM feedback records, the first-article inspection data, the change log, and the handoff specification. The document set is what transfers to production, so it should be produced as the program runs, not reconstructed at the handoff.
Sources
- 6CProto Rapid Prototyping Services
- 6CProto CNC Machining Services
- 6CProto Standards and Tolerances
- ISO 9001:2015 – Quality management systems
- ISO 2768-1:1989 – General tolerances for linear and angular dimensions