Why Building A PCB Test Jig Is Harder Than It Should Be And What We Did About It
If you’ve ever built a bed-of-nails test fixture, you already know the dirty truth: the hard part was never the hardware.
Drilling an aluminium plate, pressing in pogo pins, wiring a loom back to a test controller are all tractable problems. That work is mechanical, it’s visible, and when something goes wrong you can usually see it. The part that quietly eats hours, introduces silent errors, and gets re-spun at the worst possible moment is something far less glamorous: getting the test point coordinates right, and turning them into a file your machine will actually drill correctly.
We build embedded electronics at Ignys, which means we build test fixtures too. After enough painful jig spins, we got tired enough to do something about it. The result is RapidJig, a free, browser-based tool for designing PCB test jigs. Before we get into what it does, though, it’s worth being honest about why this job is so awkward in the first place. The problems are more interesting than most people expect.
Problem one: specifying test pads is deceptively brutal
A test jig lives or dies on the accuracy of its test points. Each pogo pin has to land on the centre of its target pad. On a 0.8 mm test pad, you have a few tenths of a millimetre of margin before the pin walks off the edge and you get an intermittent contact, or no contact at all.
Now consider how those coordinates traditionally get specified. You open the Gerber in a viewer, find a pad, read off its position, write it down (or paste it into a spreadsheet), and repeat that dozens or hundreds of times. Every one of those reads is a chance to transpose a digit, misjudge a centre, or grab the wrong net.
The cruel part is when the errors surface. A transcription mistake doesn’t announce itself during design. It shows up after the plate is drilled, the pins are pressed, the jig is wired, and you put a real board on it and find that three points won’t make contact. Now you’re debugging a physical object to find a data-entry error you made days earlier. That feedback loop, long, expensive, and completely back-to-front, is the single biggest reason test jigs cost more time than they should.
Problem two: “Gerber” is a standard the way English is a standard
Here’s the thing that catches people out. Gerber is an open, well-documented format. RS-274X has been around for decades, and X2/X3 added structured attributes on top. In principle, a Gerber is a Gerber.
In practice, every CAD package exports them a little differently.
KiCad, Altium, Eagle, OrCAD and the rest don’t agree on layer naming conventions. They handle aperture definitions (the shapes and sizes of your pads) with their own quirks. X2/X3 attributes are technically optional, so some tools populate them richly and others barely at all. And, maddeningly, they don’t always agree on where the origin of the board actually is. One tool puts (0,0) at the bottom-left of the board outline; another puts it at some arbitrary sheet origin left over from the schematic capture.
This is why so many jig workflows are fragile. A script or tool built around the Gerbers from one CAD package will quietly break the moment a customer sends files from a different one. You either rebuild your importer for every variant, or you spend your afternoon manually massaging files into a shape your tooling will accept.
Problem three: the coordinate-origin trap
This one deserves its own section, because it’s the bug that has humbled more engineers than any other.
If your jig software assumes a different origin than the one baked into the Gerber, your test points won’t be a little bit wrong. They’ll be systematically wrong. Mirrored across an axis. Offset by exactly the board width. Rotated 180 degrees. The pattern looks plausible at a glance, which is exactly what makes it dangerous: it passes the eyeball test, gets drilled, and only reveals itself when nothing lines up on the bench.
Any tool that wants to be trustworthy has to read the origin from the file itself and keep every test point locked to the actual pad location, so that what you see rendered on screen is genuinely what ends up under the drill.
Problem four: getting to a drill-ready file, not a nearly-ready one
Say you’ve solved all of the above and you have a correct set of coordinates. You’re still not done. A machine needs a properly formatted drill file, typically Excellon for drilling, and often G-code for routing clearance cuts and pockets. And those files are only useful if they carry a correct tool table, mapping each hole to the right tool. Your different probe diameters, pushrod holes, and clearance routing all need to point at the right tooling.
“A list of coordinates” and “a manufacturing-ready file with tool tables” are separated by a surprising amount of fiddly, error-prone work. That gap is where a lot of jig projects stall.
What RapidJig actually does
We built RapidJig to tackle all four of those problems directly, and to do it without asking anyone to install software, buy a licence, or upload their IP to someone’s cloud.
You upload your Gerbers and the board renders in the browser. The parser handles RS-274X and X2/X3, auto-detects layers, and loads multi-layer stacks, so import works regardless of which CAD tool produced the files. The origin comes from the file, not from an assumption.
You place test points visually, with snap-to-pad. Click near a pad and the point locks to its true centre, pulled straight from the Gerber geometry. Drag to reposition when you need to. No reading coordinates off a screen, no transcription, no guessing whether that figure was 12.43 or 12.48.
You design for the jig your board actually needs. A simple functional test? A two-plate setup (pin plate plus a moving plate) covers most bed-of-nails work. Need pushrods to actuate buttons, or board retention to stop flex during probing? Step up to a three-plate stack: pin, moving, and top. Each plate is configured independently, and you can place pushers and clearance zones so you’re designing around tall components and connectors before you cut metal.
You export drill-ready output. Excellon drill files and G-code routing, with proper tool tables, ready to go to manufacturing. And before you commit anything to the machine, RapidJig generates a print-ready proof PDF so a layout can be checked and signed off on paper, catching the mistake where it’s cheap to catch.
The whole thing runs in your browser, toggles between metric and imperial throughout, and is completely free. No credit card, no trial, no paywall.
Why we made it free
People keep asking about the pricing, so to be clear: there isn’t any. We’re an electronics design lab, not a software vendor. We built RapidJig to solve our own test-jig headaches, and once it worked, there was no good reason to keep it to ourselves. If it saves a fellow hardware engineer an afternoon, or saves them from a re-drilled plate the night before a production run, that’s a fair return.
It’s currently in beta, and if you build test fixtures, we’d genuinely value your feedback on it. The more Gerber variants and edge cases it sees, the more robust the parser gets.
You can try it here: rapidjig.ignys.com
If you’ve got your own war stories about test jig builds gone wrong (the mirrored drill file, the half-millimetre miss, the coordinate origin that cost you a plate) we’d love to hear them in the comments. We’ve almost certainly hit the same ones.