Test Jigs, Pogo Pins, and Production Test Firmware
If a unit can leave the bench untested, one will — and it will be the one the customer gets.
🎯 By the end you'll understand
Why "does it boot?" is the most popular test and the least useful one, and how to reason about coverage as an escape rate rather than a feeling. How to choose which of a dozen candidate checks earn their seconds and their jig cost at 25 units, at 250, and at 2,500 — and which expensive check catches nothing you will ever see. How to design test pads and a pogo-pin fixture that actually make contact, what the spring force adds up to, and why a via in a test pad is a bad day. How to write a production-test image that asserts on measured values instead of reporting that it ran, provisions an identity, and records numbers you can re-derive limits from. And how Beacon's 30 units were provisioned in about two minutes each.
KEY INSIGHTA test that cannot fail is not a test
Every production test has an escape rate: the fraction of defective units it passes. You do not get to choose whether you have one. You only get to choose whether you know what it is.
Here is the failure this lesson exists to prevent, and it is quieter than a burnt regulator. A jig is built. It flashes the firmware, waits for the board to print SELFTEST OK, lights a green lamp, and the operator moves on. Thirty units are shipped in an afternoon. Three weeks later, two of them have never reported a humidity reading, and when you finally get one back on the bench you find the SHT40's SDA pin has an open joint. The jig passed it. The jig passed it because the self-test function was written as bool ok = true; followed by a list of things that could set it false, and the I2C read that should have failed returned an error code nobody checked, and the temperature it printed came from an uninitialised variable that happened to hold something plausible.
That is not a hypothetical. It is the single most common shape of production-test bug, and it survives because it produces the output everyone wants to see. A test that reports PASS when the code ran is measuring your compiler, not your board. The discipline that fixes it is the same one Lesson 6.1 installed at the bench: predict, then compare. Every check asserts a measured value against a numeric limit that was written down first, and every check that finds nothing to compare against is deleted, because it is decoration.
A test plan is an economic argument, not a wish list. Each candidate check costs seconds (per unit, forever) and jig money (once), and buys down a specific failure mode with a specific expected rate. The right plan is the one where the last check you added still costs less than the escapes it prevents — and at 25 units, that bar excludes almost every expensive instrument you would like to own. Coverage you cannot afford is not coverage.
CORE CONCEPTWhat to test, what to skip, and how to decide
Production test is not verification. Verification asked "is this design correct?" and was answered in Stages 1 through 5 and again during bring-up. Production test asks a much narrower question: is this particular unit the same as the one we already proved correct? Everything that follows from that distinction is useful. You are hunting unit-to-unit variation — assembly defects, wrong parts, damaged parts, mis-provisioned identity — and you are explicitly not re-proving the design. That is why a jig does not sweep a regulator's load regulation curve: if the TPS62840 is soldered on correctly and its VSET resistor is the right value, its load regulation is the datasheet's problem, not yours.
So the candidate list comes from asking what can differ between two boards that came off the same reel and through the same oven. On Beacon, that list is short and concrete:
| Failure mode | Where it comes from | What actually reveals it |
|---|---|---|
| Short between a rail and ground | Solder bridge, especially on the module castellations and the USB-C pins | Rail voltage under load, or supply current at power-on. Loud and cheap to find. |
| Open joint on a signal | Insufficient paste, tombstone, warped part | Functional use of that signal — an I2C ACK from the specific address, not a device count. |
| Wrong or rotated part | Reel mis-load, CPL error, footprint error (Beacon's LED, Lesson 5.3) | The measurement that only the right part can produce: a rail at 3.30 V not 3.00 V, a green LED that reads green. |
| Sleep current out of family | A leaky part, a gate left floating, contamination under a part | A microamp-resolution current measurement in the jig. Expensive, and the only thing that sees it. |
| Weak or absent radio | Damaged module, solder under the antenna keep-out, cracked shield | Received signal strength at a fixed distance from a reference receiver. |
| Charger wrong or dead | Wrong PROG resistor, damaged MCP73831, cold joint on the thermal pad | Charge current into a dummy cell held at a fixed voltage. |
| Sensor present but wrong | Damaged die, contamination, a part from a different accuracy grade | Reading compared with a reference sensor sitting in the jig, in the same air. |
| Identity missing or duplicated | Provisioning script bug, an operator running the jig twice | Read the ID back after writing it, and check it against the register of what has already shipped. |
| Intermittent cold joint | Marginal reflow on a high-mass pad (Lesson 6.2) | Almost nothing, at room temperature, in ten seconds. This is the honest hole in every cheap jig. |
Notice the last row. Some defect classes are simply not detectable within a test budget you can justify at pilot scale. The professional response is not to pretend otherwise; it is to name the hole, estimate its size, and decide deliberately. A cold joint that conducts at 25 °C and opens at 40 °C is caught by a thermal cycle, and a thermal cycle costs ten minutes per unit and a chamber. At 25 units that is an indefensible purchase. At 25,000 units, with a warranty liability behind it, the arithmetic reverses. Lesson 6.8 is where that arithmetic gets formal; the widget below lets you feel it now.
First-pass yield is the fraction of units that pass the test the first time. Escape rate is the fraction of defective units that pass anyway. They are independent, and only one of them is about quality. A jig that tests nothing has a first-pass yield of 100 % and an escape rate of 100 %. A jig with a badly-set limit has a poor yield and a fine escape rate, and it will make you retest good boards until you loosen the limit — which is how limits get loosened for the wrong reason. Track both numbers, and record the measured value on every unit so that when a limit looks wrong you can argue about it with data.
The checks that are almost free
Three checks cost essentially nothing beyond the seconds they take, because the board is already talking to you: an I2C scan that asserts the presence of exactly 0x44 and 0x19 and nothing else, a firmware-side read of the 3.3 V rail through the same battery divider the application uses, and a read-back of the identity you just wrote. The divider has a 50 ms time constant, so that reading must wait about 300 ms after the divider is switched on — a limit set from a rushed measurement is a limit that fails good boards. Together they catch open joints on both sensors, a wrong VSET resistor, a missing pull-up, and every provisioning mistake. If you build nothing else, build those. They are also the three that a lazy self-test most often fakes, which is the subject of the code section below.
HOW IT WORKSPads, pins, and the fixture that has to hit them
A test fixture is a mechanical problem wearing an electrical costume. The electronics are trivial — a dev kit, a few transistors, a shunt. What is not trivial is landing eight spring-loaded pins on eight pads, repeatedly, thousands of times, with the board held flat against parts that are not flat.
A pogo pin (spring-loaded test probe) is a barrel containing a plunger and a spring. Full travel is typically 2–3 mm, and the manufacturer specifies a working travel of roughly two thirds of that; compress a pin to its hard stop repeatedly and the spring takes a set, the plunger sticks, and your contact resistance walks upward over a few hundred cycles. Spring force at working travel for a small 0.7–1.0 mm pin is on the order of 0.7–1.5 N each — check the specific part, because the range across series is wide. The number that matters is the sum: eight pins at about 1 N each is roughly 8 N, close to a kilogram-force, all of it trying to lift your board off the fixture. That is why a jig needs a clamp or a lever, not a hopeful hand, and why the board needs support directly under the pins rather than only at its corners — a 1.6 mm FR-4 board 35 × 25 mm will visibly bow under 8 N applied in the middle, and a bowed board makes intermittent contact on its outer pins.
Designing the pads, back in KiCad
The board side of this is decided long before the jig exists, which is why Beacon Rev A carries four pogo pads and a Tag-Connect TC2030 footprint that were placed in Stage 5. The rules are unglamorous and absolute:
Bare pad, no mask, 1.0–1.5 mm across
Solder mask over a test pad is an insulator; a mask sliver across the edge is worse, because the pin lands half-on it and reads a resistance that changes when you re-clamp. ENIG (Beacon's finish) is ideal — flat and it does not oxidise the way bare copper or HASL does.
No via in the pad, ever
An unfilled via is a hole for the pin's crown tip to fall into, and a plated-over via leaves a dimple. Either way the contact point moves between insertions. Put the via 0.5 mm away and connect with a short trace.
Two tooling holes, non-plated, on a diagonal
Locating the board on its own outline is hopeless; routing tolerance on a 35 × 25 mm board is a few tenths of a millimetre, which is a large fraction of a 1 mm pad. Two non-plated holes at opposite corners, dimensioned in the fab drawing, make placement repeatable.
Keep 2 mm clear of anything tall, and put the pads on one side
Pins need a straight run. A pad tucked beside the USB-C receptacle needs a shorter pin or a relieved plate, and every exception is a part you will have to make twice.
Double up the power pins
Contact resistance for a small spring pin is in the tens of milliohms, and it rises with wear and with any oxide it drags through. At 500 mA of charge current, 50 mΩ is 25 mV and 12 mW — tolerable. At 500 mA through a worn pin at 200 mΩ it is 100 mV, and your charger test starts failing units that are fine. Two pins in parallel on VBUS and two on GND halve the problem and give you a redundancy you will be glad of.
Beacon's jig is an ESP32 dev kit and a 3D-printed frame. The dev kit drives the pins that matter (EN, GPIO9 for download mode, UART, the LED-rail sense), sits as a BLE receiver at a fixed 30 cm from the board under test, holds the reference SHT40 in the same air, and talks to a laptop over USB. Using the same silicon family as the product is not just convenience: the BLE receive path is known-good, the toolchain is already installed, and anyone on the team can read the jig's firmware. A Raspberry Pi is the alternative when you need a filesystem, a database, or a screen. What you should not do is build the jig around a bench instrument you have to borrow.
SEE ITPlan the coverage — and watch cheap checks beat expensive ones
Choose which checks go into Beacon's jig. Each one costs seconds per unit and a one-off amount of jig money, and each buys down specific failure modes at the rates Beacon's bring-up and assembly experience suggest. The planner reports the cycle time, the jig cost, the weighted coverage, and — the number that actually decides things — the expected escapes per 100 units and what they cost you in the field. Change the batch size and watch which purchases stop making sense.
Three experiments. Press Minimum: a twelve-second cycle, a jig that costs nothing, and roughly nine defective units in a hundred walking out of the door — because "it booted" is compatible with a dead sensor, a dark LED, a broken charger, and a radio you cannot hear. Press Everything at 25 units: the thermal soak alone adds ten minutes per unit and nearly a million rupiah of chamber, and it removes less than one escape per hundred. Now press Everything at 2,500 units and watch the same purchase turn sensible. Finally, start from Beacon's actual plan and remove the sleep-current check: the cycle gets 45 seconds shorter, the jig gets 420,000 rupiah cheaper, and the highest-rate defect on the whole list becomes invisible. That check is the one whose absence you would not notice until the pilot.
IN PRACTICEA test image that asserts, provisions, and records
The production-test image is a separate firmware from the application, and it is worth being clear about why. It needs to do things the application must never do: burn an identity, drive the LED rail to full brightness, run the radio continuously, and print a machine-readable transcript. Mixing those into the application behind a build flag means a shipped unit is one wrong flag away from a factory mode. Two images is one more thing to manage and one fewer way to ship a disaster.
The flow at the jig is: clamp the board, hold GPIO9 low and pulse EN to enter the ROM download mode, flash the test image, run it, capture the transcript, and only if every limit passes, flash the application image and mark it valid. The board leaves the jig running the product firmware and carrying its identity. A board that fails leaves the jig running the test image, which is a useful accident: a failed unit is trivially distinguishable on the bench because it is chatty.
/* Every check asserts a MEASURED value against a limit that was written first. Nothing sets a "pass" flag by default; the result starts as FAIL. */ typedef struct { const char *name; float lo, hi, val; bool ran; } check_t; static check_t C[] = { { "rail_mv", 3200, 3400, 0, false }, // GPIO4/ADC1_CH4; settle 300 ms first { "temp_c", 18, 34, 0, false }, // SHT40 alive AND sane { "temp_err_c", -1.0, 1.0, 0, false }, // vs the jig's reference sensor { "rh_err_pct", -5.0, 5.0, 0, false }, { "accel_g", 0.85, 1.15,0, false }, // 1 g on Z; the jig holds the board flat { "led_delta_ma",5.0, 12.0,0, false }, // +8 mA expected; +15 mA = rotated part { "rssi_dbm", -70, -40, 0, false }, // jig receiver at a fixed 30 cm { "sleep_ua", 8.0, 12.0,0, false }, // family limit, set from 5 bring-up boards }; static esp_err_t check_i2c_identity(i2c_master_bus_handle_t bus) { /* Not "how many devices" — WHICH devices, and nothing else. */ bool sht = (i2c_master_probe(bus, 0x44, 20) == ESP_OK); bool acc = (i2c_master_probe(bus, 0x19, 20) == ESP_OK); int extra = 0; for (int a = 0x08; a < 0x78; a++) if (a != 0x44 && a != 0x19 && i2c_master_probe(bus, a, 5) == ESP_OK) extra++; printf("I2C sht40=%d lis2dh12=%d unexpected=%d\n", sht, acc, extra); return (sht && acc && extra == 0) ? ESP_OK : ESP_FAIL; } static void provision(void) { uint8_t mac[6]; esp_efuse_mac_get_default(mac); // factory-unique, read-only, free char id[13]; snprintf(id, sizeof(id), "%02X%02X%02X%02X%02X%02X", mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]); nvs_handle_t h; nvs_open("beacon", NVS_READWRITE, &h); nvs_set_str(h, "id", id); nvs_commit(h); /* Read it back through a fresh handle. Writing is not proof of storing. */ char rb[13]; size_t n = sizeof(rb); nvs_get_str(h, "id", rb, &n); nvs_close(h); printf("ID %s readback=%s match=%d\n", id, rb, strcmp(id, rb) == 0); } void app_main(void) { printf("PRODTEST %s fw=%s\n", BEACON_HW_REV, esp_app_get_description()->version); int fails = sizeof(C)/sizeof(C[0]); // start at "everything failed" run_all_checks(C); fails = 0; for (int i = 0; i < sizeof(C)/sizeof(C[0]); i++) { bool ok = C[i].ran && C[i].val >= C[i].lo && C[i].val <= C[i].hi; if (!ok) fails++; /* Log the VALUE, always. Verdicts can be re-derived; measurements cannot. */ printf("CHK %-13s %8.2f [%.2f..%.2f] %s\n", C[i].name, C[i].val, C[i].lo, C[i].hi, C[i].ran ? (ok ? "PASS" : "FAIL") : "NOTRUN"); } provision(); printf("RESULT %s fails=%d\n", fails ? "FAIL" : "PASS", fails); }
Four things in that listing are the whole lesson. The result starts at everything failed and is only reduced by evidence, so a crash halfway through leaves a FAIL rather than a partial PASS. ran is separate from the value, so a check that never executed cannot pass by holding a plausible number. The I2C function asserts identity and the absence of anything unexpected, which is what turns "two devices answered" into "the SHT40 and the LIS2DH12 answered." And every line prints the measurement next to its limits, so six months from now, when you want to know whether unit 017's sleep current was near the edge, the answer is in the file rather than in someone's memory.
The jig-side script is correspondingly dull: open the serial port, flash, parse lines that begin with CHK, require exactly the expected set of check names, append a row to a CSV with the serial number and every value, and refuse to continue if the identity has been seen before. Dull is the goal. A jig script with logic in it is a second product to debug.
The ESP32-C3's eFuses can hold a custom MAC, security settings, flash encryption keys, and secure-boot digests. Every one of those is a permanent, irreversible change to that specific chip. A provisioning script that burns eFuses will, on the day it has a bug, brick a batch in a way no rework can undo. Beacon's provisioning writes an ID to NVS and derives it from the factory MAC that Espressif already burned — free, unique, and unburnable by you. Reach for eFuses only when you have a requirement that demands them (flash encryption for a product with secrets on it), and when you do, test the script on a chip you are willing to lose.
BEACONBeacon's jig: 30 units, about two minutes each
The jig was built in a weekend from a printed frame, six spring pins, two tooling pins, an ESP32 dev kit, a 0.1 Ω shunt with a current-sense amplifier for the sleep measurement, a reference SHT40 mounted 15 mm from where the board's own sensor sits, and a lever clamp cut from 3 mm acrylic. Total hardware, including the printing: a little over IDR 950,000 — which is what the planner below charges for the same set of checks. It provisioned the five bring-up boards from Lesson 6.1 — reworked LEDs and all — and then the 25 pilot units from the second batch.
| Step | Time | What it asserts | Result across 30 units |
|---|---|---|---|
| Clamp, enter download mode, flash test image | 38 s | Module alive, flash writable, pins making contact | 30/30 — two needed a re-clamp on the first attempt |
| Rail voltage through the battery divider (300 ms settling) | 3 s | 3200–3400 mV | 3290–3320 mV on all 30 |
| I2C identity: 0x44 and 0x19, nothing else | 4 s | Both sensors present, no unexpected address | 30/30 |
| Temperature and RH against the jig's reference | 7 s | ±1.0 °C, ±5 %RH of the reference in the same air | Largest deviation 0.4 °C, 2.1 %RH |
| Accelerometer: 1 g on Z, board held flat | 2 s | 0.85–1.15 g | 30/30 |
| LED rail current step, then colour | 5 s | +5 to +12 mA and the right hue | The 5 reworked bring-up boards: one at +6.1 mA, dim. Reworked again. |
| BLE burst, RSSI at the jig's receiver | 12 s | −70 to −40 dBm at a fixed 30 cm | −48 to −53 dBm on all 30 |
| Deep sleep current on the shunt | 45 s | 8.0–12.0 µA family limit | All 30 in 9.5–10.1 µA — inside the limit, and all 30 above plan |
| Provision ID, read back, flash application | 28 s | ID unique, readback matches, app image valid | 30/30 |
Total: about 144 seconds of machine time per unit, call it two minutes plus handling. Two results deserve attention. The LED step caught a hand-reworked joint that had passed a visual inspection and a functional check on the bench in Lesson 6.2 — the current step was 6.1 mA instead of 8, and the LED was visibly dim next to its neighbours. A binary "did it light?" check would have shipped it. That is the difference between a functional test and a parametric one, and it cost nothing extra to build because the current sense was already there for the sleep check.
The second result is more uncomfortable. Every one of the 30 units measured between 9.5 and 10.1 µA in deep sleep, against a canon budget of 8 µA. The jig's limit was 8.0–12.0 µA, set from the five bring-up boards, so all 30 passed. That is a limit set from a population that already contained the defect — the classic way a systematic error becomes the accepted normal. The limit is not wrong, exactly: it correctly separates "this unit is like the others" from "this unit is broken," which is what a production test is for. But it is worth writing down explicitly, as the log did, that the jig cannot see OPEN-3 because OPEN-3 is in every unit. Design defects are invisible to a test whose reference is the design's own output. That is a job for the bring-up prediction and, eventually, for the pilot.
No charge-current test: the MCP73831's PROG resistor is a single 0402, and a wrong value would show as a charge current out of family — but testing it needs a dummy cell and an electronic load, about IDR 380,000 and 25 seconds per unit, to catch a mode nobody has seen. It was skipped, and the decision was written down with its reasoning so that when a charger failure does appear in the pilot, the record shows it was a choice rather than an oversight. No button test: the jig has no plunger, so the button is exercised by hand once per unit while the operator is waiting for the sleep measurement. No thermal soak: a chamber and ten minutes per unit are not defensible at 30 units, and the honest consequence is that a marginal cold joint on a module pad can leave this jig undetected. All three of those gaps are named in the pilot's risk list in Lesson 6.9, and one of them turns out to matter.
WEAKNESSWhere this bites
The pattern is bool ok = true; at the top of a function, a series of operations whose return codes are ignored, and return ok; at the bottom. It passes when the sensor is missing, when the I2C driver failed to initialise, when the read timed out, and when the value is nonsense — because none of those set the flag. The fix is structural, not a matter of care: start from failure, count checks that ran, compare measured values against limits declared as data, and make a check that did not execute distinguishable from one that passed. A test whose failure path has never been observed is a test you have not tested. Deliberately break a board — lift a sensor pin with a hot iron — and confirm the jig fails it. That fifteen-minute exercise is the highest-value thing in this lesson.
Beacon's sleep limit came from five boards that all shared a design defect, so the limit encoded the defect. This is not avoidable — you have to set limits from something — but it is manageable. Write limits as design predictions first (8 µA from the canon budget), record the population's actual spread separately, and flag the gap. When the two disagree by more than the measurement uncertainty, you have found either a design error or a modelling error, and either one is worth an hour. A jig whose limits are silently widened to fit the yield has been converted, one adjustment at a time, into a machine that certifies whatever comes out of the oven.
The opposite failure is real and less discussed. A jig that measures twelve parameters, sweeps the charger, and thermally cycles every unit is a small engineering project that competes directly with the product for your weeks. At 25 units, the entire pilot's escape cost is bounded by 25 field visits; a test rig that costs three weeks to build has already spent more than every escape it could ever prevent. Build the cheap checks first, ship, and let the field failures tell you which expensive check to add. That is not sloppiness — it is the same reasoning that says a 25-unit pilot exists to buy information, and information you already have is not worth paying for twice.
KEY INSIGHTHow this connects
- Debugging Embedded Systems Without a Debugger (3.9) — the machine-readable log discipline that makes a transcript parseable is the same one that makes a field unit diagnosable; the jig is that habit pointed at a board on a bench.
- Board Bring-Up: Smoke Test to First Blink (6.1) — every limit in the test image is a bring-up prediction promoted to a number. The jig is bring-up, automated and repeated.
- Assembly: Soldering, Reflow, and Rework (6.2) — the defect table there is the jig's target list, and the reworked LED joint that measured 6.1 mA is the proof that parametric beats functional.
- EMC, Noise, and Certification Basics (6.4) — next: a different kind of test, where the limit line is written by a regulator and the instrument costs more than the jig by two orders of magnitude.
- Capstone: Beacon Pilot Deployment and Post-Mortem (6.9) — the CSV this jig writes is the baseline every pilot anomaly is compared against; three of the gaps named above are revisited there with field evidence.
Test is the first place where the course's engineering habits meet a production rate. Everything before this lesson was about getting one thing right once. From here on, the question is whether you can get the same thing right thirty times without looking.
GLOSSARYKey terms introduced
- Escape rate
- The fraction of defective units that pass the test and ship. Distinct from yield: a test that checks nothing has perfect yield and total escape. It is the number a test plan should be argued in.
- First-pass yield
- The fraction of units passing the test on the first attempt. Low yield with a correct limit means a process problem; low yield with a wrong limit means a test problem, and the two are distinguished by looking at the recorded measurements.
- Pogo pin (spring-loaded probe)
- A sprung contact used to touch a bare test pad without a connector. Characterised by tip style, full and working travel, spring force at working travel, and contact resistance; the total force of an array is a mechanical design input.
- Test pad
- A bare, mask-free pad, typically 1.0–1.5 mm across with no via in it, placed for probe access and located by non-plated tooling holes rather than by the board outline.
- Parametric vs functional test
- A functional test asks whether something happened; a parametric test asks what value it had. "The LED lit" is functional; "the rail current rose by 6.1 mA against an 8 mA expectation" is parametric, and only the second one catches a degraded joint.
- Provisioning
- Writing a unit's identity and configuration during manufacture and verifying it by read-back. Beacon derives its ID from the factory eFuse MAC and stores it in NVS, avoiding any irreversible eFuse write.
- Test limit
- The numeric window a measurement must fall inside. Derived first from the design's prediction and only secondarily from the observed population, so that a systematic defect present in every unit is visible as a gap rather than absorbed as normal.
- Download (boot) mode
- The ESP32-C3 ROM state entered with GPIO9 low at reset, used by the jig to flash both the test image and the application. The same strapping behaviour Beacon's button shares, used deliberately here.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1A jig prints "I2C: 2 devices found" and passes the unit. Name two distinct defects this check will pass, and rewrite the assertion so it catches both.›
It passes a board where the SHT40 is dead but two other things answer — a stuck bus can make several addresses appear to ACK, and a wrong part fitted at the wrong address counts as a device. It also passes a board where one sensor is missing and the bus is noisy enough to produce a phantom ACK. The count is a proxy for what you care about, and proxies fail silently. The assertion has to name identities: probe 0x44 and 0x19 specifically, require both to ACK, and separately sweep the rest of the address space requiring zero unexpected responses. "Two devices" becomes "the SHT40 answered, the LIS2DH12 answered, and nothing else did," which is a statement about the board rather than about a number.
2Beacon's sleep-current limit was 8.0–12.0 µA and all 30 units measured 9.5–10.1 µA, about 2 µA above the design budget. The jig passed them all. Was the limit wrong?›
Not for the job a production test does. The jig's purpose is to separate units that differ from the proven population, and on that criterion 9.5–10.1 µA is a tight, healthy family with no outliers — exactly what you want to see. The limit is doing its job. What the episode exposes is a boundary: a production test cannot detect a defect that every unit shares, because its reference is the population itself. Systematic design errors are caught by comparing against the prediction, which is bring-up's job, and by the field, which is the pilot's. The correct action is what the log did: pass the units, record that every one of them sits above plan, and keep the anomaly open with its own ID rather than letting a passing test close it.
3Why does the jig put two spring pins on VBUS and two on GND, when one of each would carry the current on paper?›
Because contact resistance is the parameter that degrades, and it degrades into your measurements rather than into an obvious failure. A small spring pin starts in the tens of milliohms and rises with wear, oxide, and flux residue dragged off boards. At 500 mA of charge current, 50 mΩ is a 25 mV drop — harmless. At 200 mΩ on a worn pin it is 100 mV, which moves the voltage the charger sees and starts failing good units on a charge-current limit. Two pins in parallel halve the resistance and halve its drift, and they give redundancy if one plunger sticks. The general rule: put redundant contacts on any path that carries current you are measuring, because on those paths the jig's own wear looks exactly like a product defect.
4You have an afternoon and no budget. Which three checks do you build first for a board like Beacon, and what do you consciously give up?›
The three that need no instrument because the board measures itself: an I2C identity assertion, a rail-voltage reading through the divider the application already uses, and an identity write with read-back. Those cost seconds each and zero rupiah, and between them they catch open joints on both sensors, a missing pull-up, a wrong VSET resistor, a short pulling the rail down, and every provisioning mistake — which together is the bulk of what an assembler's process actually produces. What you give up is everything that needs an instrument in the jig: sleep current, which is the highest-rate defect class and completely invisible without a microamp-capable shunt; radio strength, which needs a reference receiver at a fixed distance; charge current, which needs a dummy cell; and anything temperature-dependent, which needs a chamber. Give them up explicitly, in writing, with the expected escape for each — so that the decision can be revisited when the volume changes rather than rediscovered when a customer calls.