| Episodes | 41 |
| Mentions | 45 |
| Cited here | 39 |
| First — last | #4 — #711 |
| Top guests | Omer Kilic, Jeff Keyzer, Zach Hoeken |
| Related | 3d printing · pcb fabrication · development board · internet of things · kicad |
Rapid prototyping is the practice of producing physical or functional versions of a design quickly enough that the design can be corrected by observation rather than by analysis. In electronics it spans quick-turn printed circuit board services, in-house fabrication such as milling and additive printing, assembly from stock development boards and modules, and software techniques such as interpreted on-target languages that remove the compile-and-upload cycle.[140][208][422][530] Its central premise is that every design begins with incomplete information, so pushing an imperfect version out and learning from it generally beats extending the design phase.[88] The economics that make it viable have shifted: bare prototype boards now cost a couple of dollars each, and where materials once rivalled the non-recurring engineering cost of a one-off or ten-off build, materials are cheap while engineering effort remains expensive.[422]
Rationale
Because information is always incomplete at the start of a design, the productive move is usually to release something imperfect and learn from it rather than to keep refining on paper.[88] The exception is a product with a single high-stakes introduction, where there is no opportunity to iterate in the market and the first release must be both fast and correct; most other hardware can absorb mistakes in later revisions.[88]
Certain design questions cannot be settled from a schematic or a screen at all. Anything that depends on how a device feels in a user’s hands requires hands-on testing, which is the specific need that forces a same-day physical prototype.[260] The same logic applies to component selection where feel and size govern the choice: physical access to a components market lets candidate switches be held and compared, whereas ordering by mail forces buying roughly twenty of a switch just to find the right one.[121]
Continuous verification in hardware is preferable to a long written specification, because implementation regularly reveals that specified behaviour cannot actually be achieved; a sixty-page document written up front can mandate what turns out to be unimplementable.[295] Breadboarding and soldering quick prototypes at each step, then measuring connectivity, response time and range on real test clusters, verifies a system incrementally instead.[295]
The economics have also inverted. Where materials once cost as much as the non-recurring engineering for small builds, cheap materials and expensive engineering time now argue for spending money on parts to save engineering effort.[422] Bare prototype PCB cost has fallen to a couple of dollars per board, and where printing is available at the cost of materials the consumables are negligible, so schedule pressure rather than parts cost now decides how a prototype is built.[422]
Board fabrication and turn time
Prototype turn time is a purchasable parameter rather than a fixed property of the process. The choices are a local board house at a premium, a distant one that costs schedule, or expedited shipping; building prototypes close to home is standard practice because speed dominates every other consideration at the prototype stage.[140] The price spread is wide: a pooled low-cost service returns boards in roughly one to two weeks, while a domestic quick-turn house charges on the order of five to seven hundred dollars for overnight or two-day delivery.[232]
When a board can be respun in a couple of days, the cost of an individual layout mistake collapses and designers stop treating each spin as precious. Commodity PCB pricing and turn time, rather than any change in design skill, are what make that posture rational.[141] Planning for multiple spins up front similarly removes the pressure to verify everything on the first board, so the first version can be committed rather than endlessly refined.[255] Not every choice is equally reversible, however: architectural picks such as the microcontroller and its software ecosystem propagate through every later revision, while most of the rest of a board can still be changed several revisions in.[255]
Home fabrication follows the same arithmetic. Etching boards at home was worth doing when the alternative quick-turn service in Australia charged around a hundred dollars, and the reasoning stopped applying once that price fell to about twenty dollars.[260] Where a self-made board still wins, the driver is usually the deadline rather than the cost: having a weekend to finish something rules out any service whose turn time exceeds the schedule regardless of price.[260]
Some approaches remove the fabrication cycle from the loop entirely. A prototyping board can be fabricated as a blank template covered in a regular cross pattern of vias, so circuits are assembled onto a stock substrate instead of waiting for a custom board on each iteration.[710] Printing channels and filling them with conductive silver ink builds a board up layer by layer, allowing arbitrarily many layers with rapid iteration rather than a fabrication cycle per revision.[505]
In-house fabrication
Keeping fabrication in-house compresses the mechanical iteration loop to roughly ten iterations in a single day, against a loop measured in shipping cycles when parts are made elsewhere.[625] Intellectual property containment is sometimes the driver rather than turn time, since every external vendor in the loop is another place a design can leak.[406]
Additive and subtractive machines differ sharply in what they demand of their own structure. Additive prototyping machines exert essentially no cutting force, so an extremely floppy and mechanically poor frame still produces a part, whereas a subtractive machine with the same frame stalls or crashes into the work.[208] Commercial desktop circuit board mills cost about five thousand dollars for a machine that is neither fast nor especially precise, which motivated a wave of open replacement designs.[208] Milling is generally not worth it for high-complexity boards, but suits rapid iteration where the value is having a physical board the same day; the trace fineness a skilled operator achieves on a mill is easy to underestimate.[454]
Owning fabrication capability does not by itself close the loop. Desktop placement capability down to 0402 parts still leaves the problem of obtaining a board, which makes milling or an outside fab the remaining bottleneck.[710] The machine platform is largely independent of the material chemistry: the same motion hardware and control software used for printing circuits was repurposed for rapid prototyping of athletic footwear by swapping the deposited material to polyurethanes.[505]
Printed mechanical parts carry their own limits. Printing enclosures in-house is a prototype and short-run technique only, since the economics invert once quantity is involved, making a printed case a placeholder for a moulded one rather than a substitute.[80] Going from a printed pattern to a usable metal part is a large amount of additional work, and large parts must be printed in several pieces, leaving a seam in the finished casting.[472]
Assembly from existing parts
Reusing a part or subsystem already known to the designer, even when it is neither the cheapest nor the technically best choice, is the correct move when speed is the binding constraint, with fully custom design reserved for the piece that genuinely has to be custom.[460] Reaching for whichever tool one is already fluent in follows the same reasoning when the goal is a demonstration rather than a product, because a crude prototype that exists communicates more than an optimised one that does not.[235]
Where there is no schedule for a full custom board, a working proof of concept can be assembled from an off-the-shelf development board, a small custom sensor board mated to its standard pinout, an existing screen module, and a printed case around the stack.[422] Such a prototype can cost ten to twenty times what the same function would cost in a production design, and that premium is still the right trade when the deliverable is a demonstration that has to exist by a date.[422] Developing custom hardware typically takes on the order of six to eight weeks plus substantial engineering effort before anything exists to test, which is the argument for starting on a development kit carrying every connector the eventual system needs.[608] Kits stop being the right answer once volumes rise, and the custom engineering effort to productise a module-based design runs on the order of fifteen to twenty-five thousand in euros or dollars.[608]
Choosing a widely-supported development board form factor lets existing compliant peripheral boards be stacked on without new hardware, and the software already written for those peripherals is reused as-is.[525] Fitting ordinary square header pins to a module and sliding the mating board onto them gives a friction-fit connection with no soldering, so modules can be added and removed freely while a prototype is still changing.[723] Once the arrangement is settled, the pins are left unpopulated and the module is reflowed directly onto the baseboard; for that to work the baseboard’s through-holes should be replaced with surface pads that will take solder paste.[723] Proprietary connector ecosystems tax this kind of work directly: a plain push button carrying one vendor’s end plug sold for around eighteen to twenty dollars, enough to justify having a mould made for the connector.[167]
A complete one-off can be assembled by exporting the board’s 3D view into a mechanical modelling tool, designing the case around it, and printing that case over a cheap pooled-service PCB, for under about a hundred dollars in total, though the result is unlikely to look finished.[191] Building a 3D model of board and enclosure before any hardware exists catches mechanical fit problems for free, which is why EDA packages added 3D mechanical views; an electrical engineer working this way is expected to do at least basic mechanical modelling and integrate it with the PCB.[4] Laying out a grid of pilot holes across a structural part lets components be moved and re-screwed as the design settles, which matters most on early prototypes where proportions are still being guessed; machining a single hole is unforgiving by comparison, since a misplaced one means remaking the part.[331]
Software and firmware techniques
High-level interpreted runtimes such as Lua virtual machines and Python are worth using to churn out proofs of concept quickly, but a design intended for production beyond a handful of units warrants being redone in a lower-level implementation.[295] Interpreted on-target languages are productive precisely in the one-to-ten-unit regime where prototypes live, and are the wrong choice for runs of hundreds of thousands where the per-unit cost of the overhead dominates.[375]
Removing the compile-upload-verify cycle changes the working loop to edit-and-save with the result visible live, which constitutes a different development paradigm rather than a marginal speed-up of the same one.[530] An on-device interpreter prompt reached over a serial link can report its own pin mappings on request, removing datasheet lookups from the bring-up loop, which suits work where timing is not tight and the aim is to get something functioning quickly.[403] A visual programming environment shows the result of a change instantly, which makes it useful for shaping an idea before committing to firmware; the work can then either stay in that environment or be rewritten and optimised in compiled code.[292] On the hardware side, a microcontroller with native USB removes the USB-to-UART converter from a prototype board entirely, cutting one part and its associated layout and driver problems from every early spin.[578]
Layout tools contribute their own shortcuts. Some let a placed component instance have its pads edited without touching the library part, which is fast when a nearly-right footprint has to be fudged onto a prototype by enlarging a hole or a pad.[162] The hazard is that the board no longer matches the known-good library footprint, so the association between verified library part and fabricated copper is silently lost.[162]
Prototypes as experiments
A prototype can be built to test a hypothesis rather than to demonstrate a function. Before building a test rig, the aim of the test and the criteria for success and failure should be stated explicitly, and the absolute minimum and fastest way to test that single theory should be found rather than the version that also delivers the eventually desired features.[260] Constraining a test to its simplest form tends to surface equipment repurposed far outside its intended use, and such improvised rigs can answer the question adequately; office-store inkjet printers served as the starting apparatus for a conductive-ink printing venture.[260]
For a complex instrument whose workflow is unproven, printing full-scale shells of every external component and staging them in a mock lab produces a testable workflow in very little time, with none of the internal engineering built.[159] A prototype in which every interaction is faked behind the scenes still yields valid workflow data, because the customer operating it cannot distinguish the mock from a working unit and behaves as they would with the real device.[159] Such a mock-up is a variable experiment rather than a fixed demo: price, configuration and workflow difficulty can be changed between customer sessions, so each session tests a different hypothesis at no fabrication cost.[159] The lever that gets a minimum viable product to market faster is cutting the requirements list rather than working the existing requirements faster, which is why the specification document is where a prototyping effort should be aimed.[159]
Putting the first crude units directly into the hands of people who are neither developers nor engineers exposes usability failures immediately; requiring a JTAG box to program a device is the kind of barrier that only appears when a non-specialist tries to use it.[336]
Compressed schedules
Compressed hardware schedules are achievable when scope is fixed and the design is simple: a conference badge went from design through manufacturing in about eight weeks.[161] A maximum power point tracker for satellite solar cells went from concept to fabricated PCB to integration in two flight vehicles in about three weeks, the pace an agile aerospace programme can sustain when it accepts flight risk.[220] New hardware is flown on two vehicles rather than one so that losing contact with a single unit does not destroy the experiment; redundancy at the vehicle level is what makes flying an unproven board acceptable.[220] After a launch vehicle carrying their payloads exploded, one satellite team rebuilt and prototyped replacement hardware in nine days to make the next rocket, a documented upper bound on how fast flight hardware can be reconstituted.[227]
Failure modes
Speed creates failure modes of its own. Validating only two or three prototype units before releasing a design to volume production is not enough to expose marginal component values; in one badge run, thirty to forty percent of units coming off the line failed and the factory had to stop the line.[161] Suboptimal crystal load capacitors are the classic marginal fault of this type: a small handful of prototypes will start reliably while a large production population will not, so oscillator load capacitance deserves explicit verification rather than a pass on a few working boards.[161]
A prototype is not finished when the board works, because documentation and host software are part of what a user needs; early users tolerate gaps but mainstream ones do not, and each point of friction costs roughly thirty percent of them.[232] Cheap printing and quick-turn boards make it easy to spin hardware fast, but finishing with something that does about eighty percent of what was promised is not a deliverable.[711]
A prototype can also be mistaken for a product. A cast acrylic shell with a story attached demonstrates industrial design, not a working product: such a mock-up contains no electronics, no firmware and no software, and presenting one as finished is how crowdfunded vapourware happens.[314]
Finally, shortening turnaround does not simply save time. It resets what managers and customers expect of a design cycle, so the saved time is absorbed by additional requirements rather than banked, and faster tooling tends to add scope to an electrical engineer’s job rather than shrink it.[4] Reviewing a product that passed through five successive generations of microcontroller, the corrective judgment was that more prototypes and faster failure would have been better than the path actually taken.[336]