End-of-line testing for your first production batch
What end-of-line testing should check on a first production batch of a connected device: fixtures, flashing, sleep current, radio and logs.

A connected device that works on the bench is not the same as a hundred devices that work in boxes. End-of-line testing is the short, repeatable check every unit passes before it leaves the assembly line, and on a first production batch it is often the piece nobody planned for.
This post is for founders and engineers heading into their first run of a few hundred to a few thousand units. It covers what the test should prove, how to design the board so it can be tested, and how to keep the results useful long after the batch ships.
What end-of-line testing is for (and what it is not)
End-of-line testing answers one question: was this particular unit built correctly? It is not design verification. By the time you reach production, the design should already have been through bench testing, environmental runs and pre-certification. The line test assumes the design is right and looks for assembly faults.
That distinction keeps the test short. Typical faults on a small-batch run are predictable:
- Solder bridges and opens, especially on fine-pitch QFNs and connectors
- Missing, rotated or wrong-value parts
- Damaged or mis-placed antennas and RF matching components
- Batteries, displays or sensors fitted in the wrong orientation or poorly seated
- Firmware not flashed, flashed with the wrong build, or missing device identity
A good test catches each of these with a measurement, not a visual check by a tired operator. Automated optical inspection helps with placement faults, but it cannot tell you whether the radio transmits.
Designing the board to be tested
The cheapest place to make a product testable is the schematic.
Test points and fixture access
Plan for a bed-of-nails fixture from the start: spring-loaded pogo pins pressing onto exposed pads on one side of the board. Put all test points on the same side, ideally the bottom. Pads of around 1 mm diameter at 2.54 mm spacing are easy to probe reliably; smaller pads and tighter pitch are possible but make the fixture more expensive and more sensitive to board tolerance. Add two tooling holes so the board registers in the same position every time.
At minimum we want access to every power rail, ground, the programming interface (SWD for STM32 and nRF parts, UART plus boot strapping for an ESP32), a debug UART for test commands, and the battery or supply input so the fixture can power the board through a measurement path.
A test mode in firmware
The production image, or a dedicated test image, needs a way to be told to run self-checks and report back. A simple command protocol over UART is enough: read sensor IDs, toggle LEDs and outputs, start a radio transmission, enter deep sleep on request. Lock the commands out once the unit is provisioned.
A practical end-of-line testing sequence
For most small connected devices, a single fixture station can run the whole sequence in well under a minute per unit. The order matters, because an early failure should stop the test before it damages anything or wastes time.
- Power-on checks. Apply supply through a current-limited source. Check input current is within limits, then measure each rail. A short on a rail shows up here before anything else is powered.
- Program and verify. Flash the bootloader and application, then read back and verify. Record the exact build hash.
- Identity and provisioning. Write the serial number, device certificate or keys, and any calibration constants. Read them back.
- Peripheral checks. Read the ID registers of every I2C and SPI device. Take one reading from each sensor and check it is plausible for room conditions, not that it is accurate.
- Inputs and outputs. Drive LEDs, buzzers and relays; the fixture senses them with photodiodes, a microphone or simple voltage checks. Buttons can be pressed by the fixture or confirmed by the operator.
- Radio check. Have the unit transmit and measure received signal strength at a fixed reference receiver, or have it scan for a beacon and report RSSI.
- Sleep current. Command deep sleep and measure current. This is the single most valuable test for a battery product.
- Final state. Put the unit into shipping mode and log the result.
The two measurements people skip
Most teams remember to flash firmware. Fewer measure the radio and the sleep current, and those are exactly the faults that show up later as complaints about range and battery life.
Radio: compare against a golden unit
Full conducted RF measurement needs a test connector and proper equipment, and it is rarely justified on a first batch. A relative test is usually enough. Put the fixture in a small shielded box, place a reference receiver at a fixed distance, and record RSSI from each unit. Characterise a set of known-good boards first and set the limit from their spread. A missing matching component or a cracked chip antenna typically shows up as a drop of many dB, far outside normal unit-to-unit variation. Our post on PCB antenna placement explains why small layout and assembly changes move these numbers so much.
Sleep current: measure it properly
Deep sleep on modern microcontrollers sits in the single-digit microamp range, often less for the core alone, and a whole board may target somewhere between a few and a few tens of microamps depending on what stays powered. A leaky capacitor, a floating GPIO or a sensor that never entered its low-power mode can multiply that and quietly cut battery life from years to months. A standard multimeter on its microamp range, or a dedicated source-measure instrument, can catch this if you let the reading settle for a second or two after the board enters sleep. Set the limit from known-good units, not from the datasheet. We go deeper on where that current tends to hide in where the microamps really go in low-power design.
Setting limits and logging results
Every measurement needs a lower and upper limit, and those limits should come from data. Build or select a group of known-good units, run the full sequence on each, and set limits with sensible margin around what you see. Then sanity-check them against the design: a limit that passes a board with a missing pull-up is too loose.
Log every result, not only pass or fail. Each record should hold at least:
- Serial number and hardware revision
- Firmware build hash and test software version
- Every measured value with its limits
- Timestamp, station ID and operator
This costs very little and pays back the first time a field return arrives. You can look up exactly how that unit measured on the day it was built and compare it with its neighbours. A simple database or even structured CSV files uploaded to the same backend as the fleet data is enough at this scale.
Fixture options by batch size
| Approach | Suits | Trade-off |
|---|---|---|
| Manual probes and a script | Tens of units, pilot runs | Cheap, but slow and operator-dependent |
| Hinged pogo-pin fixture with a small controller board | Hundreds to low thousands | Moderate cost, repeatable, reusable across revisions if pads stay put |
| Contract manufacturer’s in-circuit test plus your functional test | Larger volumes | Best coverage, highest setup cost and lead time |
For a first batch, the middle option is usually right, and it travels to the contract manufacturer with clear instructions.
What we would do before the first batch
- Add a test point list to the schematic review, not the layout review.
- Write the firmware test mode alongside the product firmware, and test it on prototypes.
- Build the fixture on the last prototype revision, so it is debugged before production boards arrive.
- Characterise known-good units and set limits from their data.
- Measure sleep current and radio on every unit, not a sample.
- Log every value against the serial number and keep it with the device records.
- Agree with the manufacturer who runs the station, what happens to failures, and who sees the logs.
End-of-line testing is not glamorous, but it is the difference between a batch you can stand behind and a batch you have to apologise for. It is far cheaper to plan it alongside the hardware than to bolt it on when the boards are already in the post.