# What a hardware project audit checks before a handover

> What a hardware project audit should check before a new team takes over: design files, BOM risk, firmware builds, signing keys and test evidence.

- Author: Milo Perović, Founder & lead engineer
- Published: 2026-10-19
- Topic: Process

A hardware project rarely arrives at a new team in a clean state. The previous contractor has moved on, the prototype half works and nobody is sure which schematic matches the boards on the desk. A proper hardware project audit is how we find out what has actually been inherited before anyone promises a date or a price.

This post is for founders and product managers who are about to hand a stalled or orphaned device project to someone new. It sets out what we check, in what order, and what the answers usually mean for the plan.

## Why a hardware project audit comes before any estimate

Software can often be read, built and run in an afternoon. Hardware cannot. The truth of a device is spread across schematic files, layout databases, a bill of materials, firmware, enclosure CAD, test notes and the physical boards themselves, and those sources frequently disagree with each other.

Without an audit, any estimate is a guess about which of those sources is correct. We would rather spend a short, fixed effort finding out than discover halfway through the Exact phase that the layout files are two revisions behind the boards. The audit also gives the client something useful in its own right: a written picture of the project they can take to any team, including us.

## Design files: native sources or just outputs

The first question is whether we have the files a design was made in, or only the files it was exported to. Gerbers, PDFs of schematics and STEP models are outputs. They let you order the same board again, but they do not let you change it sensibly.

- **Schematic and layout:** native project files from the original EDA tool (KiCad, Altium, OrCAD and so on), with libraries included. A layout without its footprint and symbol libraries is only partly usable.

- **Revision match:** the board revision printed on the silkscreen should match a tagged revision of the files. We check this physically against the boards we receive.

- **Enclosure CAD:** native, parametric files from the original CAD package, not just STEP or STL. A STEP file can be re-modelled, but every feature has to be rebuilt by hand.

- **Manufacturing pack:** assembly drawings, pick-and-place files, stack-up and any notes sent to the PCB fab and assembler.

If only outputs exist, that is not fatal, but it changes the plan. Small fixes can be patched onto exported data; anything larger usually means recapturing the schematic, which we cost explicitly rather than hiding in a buffer.

## The bill of materials and supply risk

An inherited BOM is often the place where a project quietly expires. We check every line against distributor and manufacturer data for lifecycle status, stock and second sources.

The common findings are predictable:

- Parts marked not recommended for new designs or end of life, sometimes chosen because they were in a drawer during prototyping.

- Single-source components with no pin-compatible alternative, especially sensors, PMICs and RF modules.

- Generic passives with no voltage, tolerance or dielectric specified, which makes the assembled result depend on what the assembler happened to stock.

- Mismatches between the BOM and the schematic, such as a value changed on the bench and never written back.

For a pre-certified radio module, we also note which module and antenna configuration any existing test reports refer to. Swapping either can affect whether those reports still apply, so it belongs in the audit rather than as a surprise later.

## Firmware: can we build exactly what is running

The firmware test is simple to state: from the repository we are given, can we produce a binary identical in behaviour to the one on the devices? Surprisingly often, the answer is no.

We look for a pinned toolchain version, SDK version (ESP-IDF, STM32Cube, Zephyr or similar) and all dependencies, ideally captured in a container or lock file. We check whether the version reported by a device maps to a commit, whether there is a bootloader and how it is built, and whether there are local patches to vendor code that live only on a former developer's laptop.

### Keys and secrets

This is the item founders most often overlook. If the devices use secure boot, signed firmware or encrypted flash, the signing keys are part of the product. Without them, devices already in the field may never accept another update. We check where the keys are, who controls them and whether any have been committed to the repository. Our piece on [secure OTA updates for small fleets](https://miloperovic.com/journal/secure-ota-updates-for-small-fleets-without-a-big-platform/) covers why this matters once a fleet exists.

We also look for credentials baked into firmware or apps: cloud API keys, Wi-Fi passwords, shared MQTT logins. These need rotating before anything ships, and the audit records each one.

## Test evidence and certification status

Claims such as "it passed EMC" or "battery lasts a year" need evidence behind them. We ask for the actual reports, the board revision and firmware version they were run on, and the conditions of the test.

A pre-scan done on an earlier revision is useful history but not proof for the current one. A battery-life claim is only meaningful with a measured current profile, a stated reporting interval and a temperature. Where evidence is missing, we do not assume failure; we list the test as outstanding and estimate what it will take to run it.

ClaimEvidence we wantTypical gap

Passes EMCLab or pre-scan report, revision and setupTested on an older board

WaterproofLeak or ingress test method and resultsTested once, by hand

Battery lifeCurrent profile, interval, temperatureCalculated from datasheet sleep figures

Field readyUnits running, failure logOnly bench units exist

## Ownership, access and the people behind it

Technical files are only half of what is inherited. The other half is access. We list every account the product depends on: the code repository, cloud provider, domain and DNS, app store listings, the PCB fab and assembler accounts, and any component reservations. Each one needs a named owner on the client side, not on the former contractor's personal login.

We also check licences. Commercial EDA libraries, RTOS licences, fonts in the app and third-party SDKs can each carry terms that matter once the product is sold. Where possible, a short call with the previous developer saves days of reverse engineering; where that is not possible, we note what could not be confirmed.

## What we would do before handing a project over

The audit ends in a short written report with each area marked as usable, needs work or needs replacing, and a recommendation: continue the existing design, rework specific parts, or restart from a clean architecture while keeping what is sound. That recommendation then feeds straight into the Abstract phase of our [CAEC process](https://miloperovic.com/journal/what-the-caec-process-looks-like-on-a-typical-project/), so the costed plan is built on facts rather than hopes.

If you are about to change teams, you can make any audit faster and cheaper by gathering these first:

- Native schematic, layout and enclosure files, with libraries, for the latest revision.

- The BOM as actually ordered, plus any assembler quotes or notes.

- Repository access, the build instructions and the firmware version on each device you hold.

- Signing keys and credentials, transferred to accounts you control.

- Every test report you have, labelled with the revision it covers.

- Two or three working units and, ideally, one that has failed.

None of this needs an engineer to collect. Doing it while the previous team is still reachable is the single most useful thing a founder can do for the next one.
