跳到正文
ThingWeave让项目沿着证据继续

Blog

Hardware Prototype Stages: What Each One Proves and What to Build First

"Prototype" is one word for several very different things. A breadboard with a sensor taped to it is a prototype. So is a 3D-printed shell with nothing inside, and so is a near-final unit built with production parts. Each of these answers a different question, costs a different amount and fails in a different way.

Mixing them up is one of the most common reasons first hardware projects stall. People build a beautiful enclosure before they know the electronics work, or spend months perfecting a circuit nobody has held in their hand. This guide walks through the usual prototype stages, what each one is meant to prove, and how to decide which one you need next.

Why stages matter

A prototype is an experiment. Its job is to reduce one specific risk as cheaply as possible. If you can't say which question a prototype answers, you are probably building too much at once.

Before you build anything, it helps to write down your riskiest assumption. Our guide on what to do first with a hardware idea covers how to find it. The prototype stages below are simply different tools for testing different kinds of assumptions. If you are building a hardware product from scratch, start with stage 1.

Stage 1: Proof of concept

Question it answers: Can the core thing physically work at all?

A proof of concept (POC) ignores size, looks and cost. It is usually a development board (an Arduino, ESP32 or Raspberry Pi), off-the-shelf modules, jumper wires and a laptop. The goal is to see the key effect happen once: the sensor detects what you need, the motor moves the load, the battery lasts long enough in a rough test.

Good signs you're done: you have measured the key number (range, accuracy, run time, force) and written it down, along with the conditions you measured it in.

Common trap: polishing the POC. If it works on a messy bench, move on.

Stage 2: Works-like prototype

Question it answers: Does the full set of functions work together, roughly at the intended scale?

A works-like prototype combines all the main functions: sensing, power, control, connectivity, user input. It may still be ugly and larger than the final product, but it behaves like the real thing. This is where integration problems appear: radio interference, power draw spikes, heat, firmware timing.

Good signs you're done: you can run the device through a realistic use session without touching the wires, and you have a list of the problems you found.

Stage 3: Looks-like prototype

Question it answers: Is the size, shape and feel right for the person using it?

A looks-like prototype is often a 3D print, foam model or machined block with no working electronics. You hand it to people and watch. Does it fit the hand, the shelf, the bag? Are the buttons where thumbs go? Is it obviously the right way up?

Many teams build looks-like and works-like prototypes in parallel because they answer independent questions. Just be honest that a looks-like model says nothing about whether the electronics will fit inside it.

Stage 4: Engineering prototype (works-like + looks-like)

Question it answers: Can the working internals fit into the intended form, with parts that could realistically be produced?

This is the first build that merges stages 2 and 3, often with a custom PCB instead of development boards. In formal product development this is close to what is called an engineering validation test (EVT) build. Expect surprises: the board doesn't fit, the antenna performs worse inside plastic, the battery gets warm. Before you order that first board, run through a PCB design review checklist for first boards.

Later stages: design and production validation

After an engineering prototype, companies usually move through design validation (DVT) and production validation (PVT) builds, which test reliability, certification and the manufacturing process. These stages involve factories, test labs and real budgets. If you are getting close, our checklist on what to prepare before contacting a manufacturer is the next read.

Choosing prototype parts and components

The right prototype parts change from stage to stage, because each stage asks a different question.

  • Proof of concept: development boards, breakout boards and off-the-shelf modules. You want the shortest path to measuring the key number, not the final part.
  • Works-like: start moving towards the kind of parts you expect to use, especially for anything that sets your power budget, radio range or size. A sensor that only works on its breakout board is a risk worth finding early.
  • Engineering prototype: parts you could realistically buy again for a production run, on your own board.

For every build, keep a parts list with exact part numbers, where you bought them and why you picked them. If a part was a stand-in, mark it as one, so that nobody treats a result from a dev-board part as proof for the final design.

If your product has Wi-Fi or Bluetooth, the radio module is one of the earliest parts to settle. A pre-certified module's grant comes with conditions, such as the antennas it was tested with and how close it may sit to people, so checking a module's FCC grant early saves a redesign later.

Planning a prototype build

A prototype build goes better when it's written down before you start. For each build, note:

  1. The one question it should answer, taken from your riskiest unknown.
  2. The pass/fail number and how you'll measure it.
  3. The parts and tools you need, including what's a stand-in.
  4. What you'll do with each result: which outcome moves you to the next stage and which one sends you back.

After the build, record what you measured, under what conditions, and what you decided. That record is what makes the next build faster.

Where FCC modules enter the hardware prototype process

Radio and compliance questions tend to surface at the works-like and engineering stages, once the radio, power, enclosure and firmware first run together. That is the point to ask whether a pre-certified FCC module still leaves work for your product, and to list anything you haven't confirmed as an open risk rather than an assumption. If the antenna, installation or use conditions do not match the module grant, compare FCC modular approval with certification under your own FCC ID before freezing the engineering prototype.

How to choose your next prototype

Ask three questions:

  1. What is the riskiest unknown right now? If it's "can this physically work", build a POC. If it's "will people want to hold or use this", build a looks-like model. If it's "will all of this work together", build works-like.
  2. What's the cheapest build that could prove it wrong? A cardboard mock-up that kills a bad idea in an afternoon is a great prototype.
  3. What result would change your plan? Decide in advance. "If run time is under 6 hours, we change the battery approach" turns a build into a decision.

The four feasibility questions are a useful frame for listing those unknowns before you choose. And if your prototype is stuck between stages, use our restart checklist.

A synthetic example

This example is synthetic, made up for illustration. It was not built or tested.

Imagine a desk device that glows when the room gets too warm.

  • Riskiest unknown: whether a cheap temperature sensor is accurate enough near a warm laptop.
  • POC: an ESP32 dev board, a sensor module and an LED on a breadboard, logging readings next to a reference thermometer for a day. Target: within 1 °C.
  • Result (hypothetical): readings drift by 2 °C when the sensor sits near the board's regulator. Decision: move the sensor away from heat sources in every later build.
  • Next prototype: a looks-like foam block to test desk size with three people, in parallel with a works-like build that adds a battery to measure run time.

Notice that each step has one question, a pass/fail number and a recorded decision.

Keep a record as you go

Prototypes produce a lot of evidence: measurements, photos, failed attempts, part choices and the reasons behind them. Months later, that record is what stops you from repeating a failed test or forgetting why you chose a part. A simple decision log works. So does a workspace your AI agent can read, so that a new chat picks up from your last result instead of starting over. See how ThingWeave handles validating a prototype you already built.

FAQ

What is the difference between a prototype and a proof of concept?
A proof of concept is one kind of prototype. It only shows the core function can work, ignoring size, looks and cost. Later prototypes add integration, form and manufacturability.

Should I build a works-like or looks-like prototype first?
Build whichever tests your riskiest unknown. If the technology is uncertain, start works-like. If the technology is proven and the question is how people will use it, start looks-like. Many teams do both in parallel.

Do I need a custom PCB for my first prototype?
Usually not. Development boards and modules are faster and cheaper for proofs of concept and early works-like builds. A custom PCB makes sense once you need the electronics to fit the intended form.

How many prototypes does a hardware product need?
There's no fixed number. Simple products may need a handful of builds; complex ones often need many iterations per stage. Plan for each build to answer a question rather than counting builds.

What should I measure during prototype testing?
Measure the numbers your product's promise depends on, such as accuracy, battery life, range or force, and write down the test conditions so you can compare later builds fairly.

Start your first project

ThingWeave is a pilot workspace where you and your AI agent keep requirements, research with its sources and decisions for a hardware idea in one place, so each prototype builds on the last.

Start your first project