You identify missing documentation in an inherited wearable prototype by auditing every layer of the system against a reference checklist: hardware, firmware, mechanical and textile design, test records, and supplier data. Anything you cannot trace back to a source file, a revision, or a decision log counts as a gap. The earlier you find it, the cheaper it is to fix.
Inherited prototypes fail most often at the seams between disciplines, where electronics, firmware and textiles meet. The sections below cover what a handover should contain, how to audit it, and what to do when the answers are not there.
Which documents should a wearable prototype handover include?
A complete wearable prototype handover includes hardware design files, a Bill of Materials, firmware source code with build instructions, mechanical and textile specifications, test results, and a record of known issues. Together these let a new team reproduce, modify and validate the prototype without contacting the original builders.
Use this as a minimum checklist:
- Hardware: schematics, PCB layout files, Gerbers, a revision history, and a system block diagram showing power and connectivity paths.
- Bill of Materials: manufacturer part numbers, suppliers, alternates, and lifecycle status for every major component.
- Firmware: source repository, toolchain and version, bootloader and flashing procedure, configuration parameters, and a note on any third-party libraries.
- Mechanical and industrial design: CAD files, enclosure drawings, and the materials used for 3D printed or moulded parts.
- Garment and textile: patterns, fabric specifications, conductive material details, and assembly instructions.
- Test and validation: test plans, raw results, user feedback, and a list of open bugs and known limitations.
- Requirements: what the prototype was meant to prove, and who defined success.
That last item is the one teams forget. Without the original goal, you cannot tell whether a quirk is a defect or a deliberate shortcut.
How do you audit an inherited prototype for documentation gaps?
You audit an inherited prototype by comparing the physical device against its paperwork, layer by layer. Start with the checklist above, open every file, and then check whether the files actually describe what you hold in your hands. Mismatches between the artefact and the documentation are the gaps that matter most.
A practical audit runs in four steps:
- Inventory. List every file, repository, and document you received. Note dates, authors and versions.
- Trace. Pick a sample of components on the physical board and find each one in the schematic and BOM. Then flash the firmware and confirm it builds and behaves as described.
- Reproduce. Ask someone who did not build the prototype to assemble or rebuild a subsystem from the documents alone. Every question they ask marks a gap.
- Log. Record each gap with a severity: blocks reproduction, blocks modification, or merely inconvenient.
This reproduction test is the most honest measure of documentation quality. Files that exist but cannot be used to rebuild anything are effectively missing.
What are the warning signs of missing hardware and firmware documentation?
The clearest warning signs are files that do not match the physical device, firmware that will not compile, components with no traceable part number, and hand-modified boards with no record of the changes. If the team that built the prototype is unreachable, treat every one of these as higher risk.
Hardware warning signs
- Visible rework: bodge wires, cut traces, or added components that appear in no schematic.
- A schematic labelled with a different revision from the board silkscreen.
- A BOM that lists generic values (“10k resistor”) but no manufacturer part numbers.
- Obsolete or end-of-life parts with no listed alternates.
- No power budget, so battery behaviour cannot be explained or predicted.
Firmware warning signs
- Source code with no version control history, or a single commit named “final”.
- Missing toolchain details, so the code will not build on a clean machine.
- Hard-coded calibration values and magic numbers with no comments.
- Only a compiled binary, with no source at all.
- Proof-of-concept scripts in Python, MATLAB or Arduino sketches that were quietly promoted into the working codebase.
That last point deserves attention. Early prototypes are deliberately rudimentary and fast, which is fine for demonstrating a principle but rarely produces maintainable code.
What documentation is often overlooked in haptic and smart textile prototypes?
The most commonly overlooked documentation in haptic and smart textile prototypes covers actuator placement and drive parameters, haptic pattern definitions, textile integration methods, and washability and wear testing. These details live in people’s heads, because they sit between disciplines and fit no standard template.
For haptic wearables, look for:
- The actuator type (ERM, LRA or piezo), model, and why it was chosen.
- Drive voltage, frequency, and timing parameters, plus the pattern library that defines each sensation.
- Actuator positions on the body and the reasoning behind them, since perceived intensity changes with location, skin contact and garment pressure.
- User perception findings, such as which patterns people could distinguish.
For smart textiles, look for:
- The integration technique used to attach electronics to fabric, such as overmoulding, stitching or bonding.
- Conductive thread, yarn or fabric specifications, and resistance values.
- Garment patterns, sizing logic, and base garment source.
- Washability, biocompatibility and durability test results, or an explicit note that none were done.
A missing textile specification is especially costly. Unlike a PCB, a sewn garment cannot be regenerated from a file, and small changes in fabric or tension alter sensor and actuator behaviour.
How can missing prototype documentation be reconstructed?
Missing prototype documentation is reconstructed through reverse engineering: tracing the board to recover the schematic, reading and decompiling firmware, characterising behaviour with test equipment, and interviewing anyone who touched the project. Start with the highest-risk subsystems and document as you learn, so the work compounds instead of repeating.
A workable reconstruction sequence:
- Photograph and label everything. Capture both sides of every board at high resolution before you touch anything.
- Rebuild the schematic. Identify components from markings, trace connections with a multimeter, and cross-check against datasheets.
- Recover the firmware. If source exists, get it building. If only a binary exists, read it from the device if readout protection allows, and treat it as a reference rather than a foundation.
- Measure behaviour. Log current draw, sensor output and actuator response across operating states. Measured data replaces missing specifications.
- Interview the people. Former developers, testers and suppliers hold knowledge no file contains. Capture it in writing straight away.
- Write it down as you go. Every recovered fact goes into a living document with a date and a confidence level.
Be honest about confidence. A reconstructed schematic that has never been verified against a built board is a hypothesis, not a specification.
When is it better to rebuild a prototype than document it?
Rebuilding is better when reconstruction would cost more than starting fresh, when the original design cannot meet its requirements, or when the prototype was only ever a throwaway demonstrator. If the architecture itself is flawed, documenting it preserves the wrong thing.
Weigh these factors:
- Reconstruction cost. If recovering the schematic, firmware and textile specification takes longer than redesigning, rebuild.
- Component lifecycle. A design built on obsolete parts needs redesign anyway, so documenting it first has limited value.
- Fitness for the goal. A proof of concept built with wired connections and off-the-shelf modules was never meant to become a product. Treat its lessons as the deliverable, not its code.
- Certification path. Medical and safety products need traceable design history. Undocumented prototypes rarely meet that bar, and retrofitting records is slower than building them correctly from the start.
- Reusable value. Often the right answer is hybrid: keep the validated concept, user feedback and requirements, and rebuild the engineering around them.
Rebuilding does not mean discarding the knowledge. Whatever the prototype taught you about users, comfort and failure modes should carry forward into the new design.
How Elitac Wearables helps with inherited wearable prototypes
We pick up wearable prototypes that other teams started and could not finish. Because hardware, firmware, textile and haptics expertise sit together in our 180m² Wearables Lab, we can audit every layer of an inherited prototype without handing pieces between suppliers. Our structured development process then turns that audit into a clear path forward.
- Documentation audit across hardware, firmware, mechanical and textile layers
- Reverse engineering and reconstruction of missing schematics, BOMs and firmware
- Review of haptic actuator choices, drive parameters and pattern design
- An honest recommendation on whether to document, repair or rebuild
- Continuation through prototyping, certification and small-series production
If you have inherited a wearable prototype and are unsure what you actually hold, contact our team and we will help you find out.
Related Articles
- How do you collaborate with a wearable developer while keeping your existing suppliers?
- How do haptic feedback wearables perform in industrial environments?
- How do haptic wearables enhance virtual reality experiences?
- How do you build a wearable product business case that gets board-level buy-in?
- How do you manage battery life constraints in wearable development?




