Smart eyewear OEM/ODM manufacturer · Shenzhen, China +86 19835872450 sales@cynrin.com
OEM & ODM

Development Process: Design and the Prototype Stage

Between the moment a requirement document is signed and the moment tooling starts being cut, there is a stage that buyers routinely underestimate. Suppliers…

By CYNRIN Engineering & Sourcing Team/ Jul 22, 2023/ 16 min read
Development Process: Design and the Prototype Stage

Between the moment a requirement document is signed and the moment tooling starts being cut, there is a stage that buyers routinely underestimate. Suppliers call it design, engineering, pre-development, or DVT. Buyers experience it as a period of drawing, questions, and samples that never quite settle anything. It is also the stage where the largest irreversible cost of the project quietly takes shape, and where the difference between a project that ships and a project that stalls is usually decided.

This article is about that stage in the CYNRIN development framework: what design actually resolves, what a prototype is and is not for, how the three different kinds of samples relate to each other, and what to ask when a sample arrives without answering the question it was sent to answer. It sits between the development process overview and the engineering and customization work that follows it.

Development process design stage: what the framework covers

In this framework, design does not mean industrial design. It does not mean styling, colour, material, or the industrial look of a headset. It does not mean producing a set of renderings that make the product look finished on a slide. None of those are the job here, and a buyer who arrives expecting them will misread the stage entirely.

Design means resolving the frozen requirement into a buildable specification. The requirement document says what the product must be. The buildable specification says how each element of that requirement is actually going to be achieved, and what it will cost in engineering effort and tooling to achieve it. A requirement is a statement of intent. A buildable specification is a statement of construction: which components, in which configuration, with which interfaces, with which software build, mounted into which enclosure, filled with which cells, packed in which carton.

The gap between the two is where projects fail. A requirement can be perfectly reasonable, well written, signed by both sides, and still not be buildable with the chosen platform. The gap shows up in the details that nobody wrote down on the requirement sheet: which codec the chip can actually output, whether the microphone array has enough headroom in the shell, whether the battery capacity requested fits the internal volume once the thermal pad and the flex cable are accounted for, whether the chosen charging connector can carry the current the cell needs, whether the band that fits the requirement will also hold the antenna geometry without shadowing it.

Resolving those details is design work. Each one is a small question with a concrete answer that someone has to produce, document, and own.

The output of the design stage is therefore not a picture and not a slide. It is a specification that the next stage can build from without guessing, plus a record of the decisions that were open when the requirement was signed and how they were closed. Where a decision cannot be closed — because the platform cannot do what the requirement asks, or because doing it would require a change of direction the requirement does not authorise — that is a finding, and findings get raised with the buyer rather than absorbed silently.

Here is what a design stage resolves in practice, and what it hands onward:

  1. Component selection against the requirement. Every line of the frozen requirement is mapped to a specific component or subsystem, with the reason it satisfies that line stated rather than assumed. Where a requirement line has no component that satisfies it, the line is marked open.
  2. Mechanical resolution. Enclosure, band, hinge, port placement, button and control layout, mounting of the electronics, thermal path, and the internal volume budget that determines what cell and board combination fits.
  3. Firmware build definition. The firmware build that corresponds to the frozen requirement: which features are enabled, which are off, which default settings are locked, and which behaviours the software is expected to produce under test. A build identifier and a feature configuration are part of the design output, not an afterthought.
  4. Tooling definition. Which parts need tooling, what kind of tooling each needs, and what the tooling produces that the assembly line consumes.
  5. Open items list. Every question the design stage could not close, with the decision owner and the question that will close it.

None of this is a marketing exercise. None of it produces a number you can put in a press release. It produces a buildable specification.

One point deserves emphasis because it is the one most often lost. The requirement document that was signed is the authority. Design does not get to quietly upgrade the product. If the design stage discovers that the requirement as written cannot be met, the correct action is to say so and let the buyer decide, not to substitute a different sensor or a different battery and treat the requirement as fulfilled by intent. A project where the product on the line differs from the product that was signed is a project where the compliance file, at a later gate, will be built against the wrong thing. That is expensive to unwind, and it is entirely avoidable here.

What we will do at this stage is close every line of the requirement against a named component or a named engineering action, and report the remainder as an explicit open-items list with owners attached. Buyers who want the gate to be meaningful should ask for that list even when it is short, and especially when it is short.

AI-generated photograph illustrating development process: design and the prototype stage — image 1 of 3

What a prototype is actually for

A prototype in this framework has one job: to prove that the risky part of the customisation is buildable. Not that the whole product is good, not that it is commercially attractive, not that it will meet expectations in the hand. It proves that the specific unknown that made the project risky has been removed.

That framing matters because a prototype program can easily expand into something enormous. People build ten samples to test six functions. People re-run a prototype when the real question was only about fit and tolerance. People treat the sample program as a demonstration. In a process with six gates, the prototype is a technical instrument with a defined question attached to it, and the instrument is only meaningful if the question is written down before the sample is built.

The risky part of a customisation is not always where people expect. It is usually the thing that is both new and consequential. Consider the common cases:

  • The new component has never been in this shell. A different display module, a different camera module, a different audio codec — each of these changes the acoustic path, the thermal path, the power budget, and the mechanical fit simultaneously. The risk is the integration, not the component.
  • The new interaction changes the control behaviour. A different control scheme, a different gesture, a different button mapping, a different pairing flow. The risk is firmware and human factors together, because a control that works on the bench can be unusable on a head.
  • The new enclosure is the first time this geometry is being built. New tooling geometry means new tolerances, new draft angles, new assembly sequence questions. The risk is manufacturing, not aesthetics.
  • The regulatory-sensitive behaviour is new. A different wireless configuration, a different power regime, a different camera arrangement. The risk here is that the compliance file, at a later gate, may not cover it.

Each of these has a different prototype question and a different evidence needed. A prototype that does not identify which of these it is testing has been built without a hypothesis, and it cannot fail usefully.

Development process design and prototype gates before mass production

Design stage resolving requirement into a buildable specification

What a prototype must demonstrate, stated as acceptance conditions before it is built:

  1. The risky part performs to the stated threshold under stated conditions. Not "works", but the measurable condition the requirement implies. A microphone that must hold a minimum isolation figure is tested against that figure, on the specific fixture agreed.
  2. The interface between the risky part and the rest of the product holds. If the risk is integration, the prototype demonstrates the integration in the real enclosure, not on a bench rig.
  3. The assembly sequence is feasible. Someone built it, in the order the production line will build it.
  4. The failure behaviour is understood. Where the risky part can misbehave under edge conditions, the prototype shows what the misbehaviour looks like and what the firmware does about it.

What a prototype does not demonstrate, and must not be sold to you as demonstrating:

  • Market acceptance. A prototype cannot tell you whether buyers will buy. That is a commercial question, and it is answered after the pilot run, not before.
  • Durability at volume. A prototype is a small build with hand assembly. It does not predict a production line's yield.
  • Cost. A prototype is the most expensive unit in the programme by unit cost, because tooling is amortised over nothing. Any cost figure derived from a prototype is an artefact of the prototype, not a product cost.
  • Regulatory standing. A prototype is not a compliance vehicle. Testing on a prototype does not create a report, and a report is not a declaration. We will be explicit about that boundary: the prototype proves buildability; the compliance file, at a later gate, is what supports a market entry claim. If a supplier offers a prototype as evidence of certification, that is a category error, and it should be corrected early.

What we will do at this gate is state the acceptance conditions in writing before the build, run the test against those conditions, and report which condition was met and which was not. A prototype that closes its question is a gate output we will sign; a prototype that does not is a finding we will put in writing rather than let pass as a general impression.

A useful discipline for buyers is to require the prototype's acceptance conditions to be written and signed before the build, exactly as the requirement document was. A prototype whose success criteria are written afterwards tend to succeed, because they were defined by the result.

Prototype acceptance conditions and evidence checklist

The other half of the question — how to tell which part of a customisation is the risky one — is a design judgement, but it is a structured one, and buyers can participate in it. The framing that works: for each customisation line, ask what would have to be true for it to work, and then ask which of those conditions is currently unknown. The line with the most unknowns that also have the most consequence is the risky line. If two lines both have unknowns, the one where a wrong answer changes the tooling is the one that has to be prototyped first, because tooling is the least reversible cost in the programme.

AI-generated photograph illustrating development process: design and the prototype stage — image 2 of 3

Engineering samples, golden samples and production samples

Three kinds of sample appear in this framework and they are frequently confused, which causes real contractual trouble. They have different purposes, different acceptance criteria, and different consequences.

The engineering sample is a build used to test. It may be hand-assembled, it may use unhardened or provisional tooling, it may have rework, and it may differ from what the production line will do. Its value is information: what works, what does not, what needs to change. It is explicitly not a quality reference, and it should never be cited as one. Buyers sometimes sign off an engineering sample in a meeting because it looks finished, and then expect the production units to match it. That expectation is the origin of a large share of the disputes in this industry.

The golden sample is the reference unit. It is the physical definition of the boundary between acceptable and not acceptable. Once signed, it is compared against, and it is what the inspection criteria for the pilot run and for production are written in terms of. Its characteristics are captured in a verification record: pairing behaviour, audio output and channel behaviour, charging behaviour and indication, any camera function and its control behaviour, and the observable cosmetic and functional baseline. A golden sample that is not documented against a written record is just another unit; the record is what makes it a reference.

The production sample — more accurately, production units built on production tooling at production volume — is the first evidence that the line can repeat what the engineering build did. This is where pilot-run-before-mass-production earns its place. Substitutions that engineering samples never reveal, because a prototype was built by hand with the real part in the right position, get revealed when a line runs a full batch: a sourcing change that has not been communicated, an alternative component that is technically equivalent on paper but visibly different, a process step that cannot be repeated at rate.

The order of these three matters to a buyer because it determines what evidence exists at which moment:

Engineering sample, golden sample and production sample compared

The sequence runs engineering samples first, because the question is technical. The golden sample follows, once the design is stable enough that a reference unit can be built and signed. Production samples come last, on production tooling, at production volume, inspected against the golden sample.

The practical consequence for procurement is that the golden sample should be signed at the samples gate, not later, and not earlier. Earlier than that and you are freezing a reference that the design is still going to change. Later than that and you have no reference when the pilot run needs one. And the golden sample itself needs a storage and custody arrangement, because it is a physical object whose condition affects its authority — a golden sample that has been dropped, stored in a hot vehicle, or used as a demo unit for a trade show is no longer a clean reference.

A buyer should ask, and should expect to receive with a prototype programme:

  1. The prototype's written acceptance conditions, signed before the build, listing what had to be demonstrated.
  2. The test evidence behind each acceptance condition, in whatever form the test produced — a measurement sheet, a video of the test, a log, a fixture photo. Not a slide saying "passed".
  3. An explicit list of what the prototype did not test, so that the untested surface is known rather than assumed empty.
  4. The as-built configuration of the prototype, including which components were actually fitted, since a prototype's configuration can drift from the specification as it is iterated.
  5. A note of every deviation from the frozen requirement, with an approval for each.

Items four and five are the ones that matter most and get sent least. The as-built configuration and the deviation list are what stop the project from drifting, and they are the evidence that makes the golden sample meaningful later.

One more buyer-side rule worth stating plainly: a sample handed over informally — a unit at a trade show, a unit couriered to an office as a gift, a unit attached to a quotation email — creates no obligations and no reference. It is not an engineering sample in this framework because it carries no acceptance conditions and no evidence. Treat it as a sales artefact, not as a project artefact.

The second thing a buyer should be able to get in writing at this gate is the transfer of custody for the golden sample. Where we build and hold the reference unit on the buyer's behalf, we will record its serial or model string, its firmware build, the date it was signed, its storage condition, and every transfer of custody afterwards. A reference whose history is unknown cannot be used to settle a dispute, because the first question in any dispute is whether the reference itself was still a valid reference.

AI-generated photograph illustrating development process: design and the prototype stage — image 3 of 3

Questions to ask when a prototype arrives

Samples arrive. They look convincing. The immediate question is usually whether they are good enough, and that is the wrong question, because good enough for what is never stated. The productive approach is to work backwards from the purpose of the prototype to the evidence that should exist, and see whether it does.

The list below is what to ask the supplier when a prototype arrives and does not settle the question it was supposed to settle. They are ordered by how often they turn out to be the actual gap.

  1. What was this prototype's written question? If there was no acceptance condition signed before the build, say so plainly and treat the result as observation rather than evidence. Observation still has value, but it cannot close a gate.
  2. Which specific line of the frozen requirement does this sample test? Design the answer in terms of the requirement, not in terms of the feature. "It tests the new audio path in the production-like shell" is an answer. "It tests the new audio" is not, because the new audio alone was not the risk — the new audio in that shell was.
  3. Which component was actually fitted, and how do we know? Ask for the as-built configuration, not the intended configuration. Where a prototype was iterated, there may be more than one revision in play; ask which revision this unit is.
  4. What did it fail? A supplier who reports only the successes has either not tested the right thing or has decided not to tell you. Ask what the unit could not do, and whether that failure was known before the build.
  5. Is this unit hand-built or line-built, and was it built with production tooling? This determines how much of the prototype result transfers to production. A hand-built unit with the real components in the right place can tell you a great deal about integration, and almost nothing about repeatability.
  6. What has not been tested at all? Compare the requirement document line by line against what the prototype exercised. The untested lines are the real exposure, and they are usually not the interesting ones.
  7. Which decisions are still open? Ask for the open-items list with owners. If a line of the requirement is still open at prototype stage, the timeline and the costs downstream are both less firm than a quotation implies, and the commercial conversation should reflect that.
  8. Does the sample match the golden sample that will be signed later? If the prototype and the future golden sample will differ in material, finish, or configuration, ask which differences are deliberate and which are just leftovers from prototyping. Prototype-era cosmetic improvisation is the most common cause of a mismatch that resurfaces during the pilot run.
  9. What does this change in tooling? Every design decision that touches a moulded part changes tooling. Ask what is now committed to steel and what is still free to move. This is the point in the process where the cost of stopping is defined, and the moment to discuss it in writing rather than later.
  10. What is the evidence trail? Ask for the documents, not the summary. A requirement document, a build specification, a deviation list, and a record of what was tested.

On that last point, be pragmatic. Most of these questions are answerable, and most suppliers will answer them if asked in a form they can respond to. The problem is not usually unwillingness. It is that the supplier's engineering record and the buyer's expectation are stored in two different shapes, and nobody has asked for a translation.

What we will do, if a prototype does not close its question, is say which acceptance condition was not met, state the gap technically, and put forward the specific next build needed to close it — rather than presenting a prototype that looks finished and moving the conversation forward. The cost of an honest unresolved answer here is a further engineering round. The cost of an unresolved answer that gets carried silently into the golden sample and the pilot run is a production batch that does not match, which is considerably more expensive.

For the wider picture of how this stage sits in the six-gate sequence, including what happens before it and after it, see the development process overview. For the specific engineering and customization decisions that follow a frozen requirement, see engineering and customization. And for how sample requests are usually handled on the buying side — including the commercial mechanics around who pays for samples and what a sample fee does and does not cover — see samples and procurement.

The single thing worth carrying out of this article is a question to ask earlier than you think: when the requirement is signed, ask which part of it is the risky part. The answer tells you what the prototype is for, what it must prove, and what will need to be true later for the production line to repeat what the sample showed.

Chat on WhatsApp
Your experience on this site will be improved by allowing cookies.