Design for Testability: PCB Best Practices

Good DFT decisions made during PCB layout directly reduce test time, fixture cost, and escapes at ICT, functional test, and in-system programming. A board that's hard to probe is hard to test automatically. This guide covers the mechanical and electrical decisions that make automated testing with OpenHTF and TofuPilot practical.

What DFT Means for PCBAs

Design for Testability (DFT) is the set of layout and schematic decisions that make a PCBA observable and controllable during manufacturing test.

Test Point Placement Guidelines

Test points are the interface between your board and the test fixture. Every net you want to probe at ICT or functional test needs one.

Physical Requirements

Place test points on a 100 mil grid where possible. Bed-of-nails fixtures are built on that grid.

Which Nets Need Test Points

Cover these at minimum:

• Power rails (VCC, VBAT, VIO, all regulator outputs)
• Ground (one per power domain)
• Digital I/O on microcontrollers and FPGAs
• Analog signal paths (input and output)
• Crystal oscillator pins
• Reset lines
• Communication buses (UART TX/RX, SPI CS/CLK/MOSI/MISO, I2C SDA/SCL)
• Programming and debug interfaces (SWDIO, SWDCLK, TDI, TDO, TMS, TCK)

Placement Rules

Put test points on the primary side (component side) when possible. Double-sided fixtures are expensive and slow cycle time. If a net only routes on the back side, add a via to the top with a test point.

Do not cover test point vias with soldermask. Soldermask-covered vias are common for density but kill ICT access.

Common DFT Mistakes and Test Cost Impact

Boundary Scan (JTAG) Considerations

JTAG boundary scan (IEEE 1149.1) tests interconnect and basic component function without a bed-of-nails fixture.

For JTAG to work in manufacturing:

• All JTAG-capable devices must be in the scan chain (no unconnected TAP pins)
• TDO of each device connects to TDI of the next
• TMS and TCK are bussed across all devices
• TRST is pulled high with a 10k resistor (active-low)
• The chain must be accessible through a header or test points

Include a populated 10-pin ARM JTAG or 20-pin JTAG header on EVT boards. Depopulate the connector on production builds but keep the footprint and test points.

Programming Headers and Debug Interfaces

Many microcontrollers have BOOT0/BOOT1 pins that select the programming mode. These need to be controllable from the test fixture. Add a test point to BOOT0.

How DFT Enables Automated Testing with OpenHTF and TofuPilot

With test points, JTAG access, and a controllable programming interface, you can build a fixture that drives the DUT through a full test sequence without human intervention.

import time
import subprocess
import serial
import openhtf as htf
from tofupilot.openhtf import TofuPilot


def program_firmware(test):
    """Flash firmware over SWD using pyocd."""
    result = subprocess.run(
        ["pyocd", "flash", "--target", "stm32g431rb", "firmware.hex"],
        capture_output=True,
        text=True,
        timeout=30,
    )
    test.logger.info(result.stdout)
    if result.returncode != 0:
        test.logger.error(result.stderr)
        return htf.PhaseResult.STOP


@htf.measures(
    htf.Measurement("vcc_3v3")
    .in_range(minimum=3250, maximum=3350),
    htf.Measurement("vbat")
    .in_range(minimum=3500, maximum=4200),
)
def measure_power_rails(test):
    """Probe VCC and VBAT test points with DMM."""
    test.measurements.vcc_3v3 = 3312  # Replace with real DMM read * 1000
    test.measurements.vbat = 3850  # Replace with real DMM read * 1000


@htf.measures(
    htf.Measurement("uart_echo_ok").equals(True),
    htf.Measurement("uart_response_time")
    .in_range(minimum=0, maximum=100),
)
def test_uart_comms(test):
    """Send command over UART, verify echo and response time."""
    with serial.Serial("/dev/ttyUSB0", baudrate=115200, timeout=1) as port:
        port.write(b"PING\r
")
        t0 = time.monotonic()
        response = port.readline().decode().strip()
        elapsed_ms = (time.monotonic() - t0) * 1000

    test.measurements.uart_echo_ok = response == "PONG"
    test.measurements.uart_response_time = round(elapsed_ms, 1)


def main():
    test = htf.Test(
        program_firmware,
        measure_power_rails,
        test_uart_comms,
        test_name="PCBA Functional Test",
    )

    with TofuPilot(test):
        test.execute(test_start=lambda: input("Serial: "))


if __name__ == "__main__":
    main()

Each phase maps to a test point or interface on the board. program_firmware uses SWD. measure_power_rails uses test points on VCC and VBAT. test_uart_comms uses the UART header.

Well-Designed Board vs. Poorly-Designed Board

DFT Checklist