What Is Adaptive Testing for Manufacturing

What Is Adaptive Testing for Manufacturing

Adaptive testing adjusts the test sequence in real time based on data from earlier test steps, historical results, or process conditions. Instead of running every unit through every test, adaptive testing decides which tests to run, which to skip, and which limits to apply based on what the data says. This guide covers how adaptive testing works, the different levels of adaptation, and where it produces the most value.

Static vs Adaptive Testing

In semiconductor testing, adaptive test has been deployed for over a decade. Advantest and Teradyne offer platforms that skip tests based on upstream wafer data, reducing test time by 10-50%. In discrete manufacturing, the concept is newer but the same principles apply.

Levels of Adaptive Testing

Most manufacturing teams operate at level 1 (fail-fast ordering) without calling it adaptive testing. Levels 2-3 deliver the biggest cycle time reductions. Levels 4-5 are emerging capabilities.

Where Adaptive Testing Produces Value

Adaptive testing delivers the most value when yield is high and the product is mature. When you're still learning, run everything and collect data.

Prerequisites

• Python 3.10+
• OpenHTF installed (pip install openhtf)
• TofuPilot Python SDK installed (pip install tofupilot)

Step 1: Implement Fail-Fast Ordering

The simplest form of adaptive testing: put the phases that fail most often first. When a unit fails early, skip the remaining phases.

import openhtf as htf
from openhtf.util import units
from openhtf import PhaseResult


@htf.measures(
    htf.Measurement("power_good").equals("PASS"),
)
def phase_power_check(test):
    """Highest failure rate test. Run first, stop on fail."""
    result = "PASS"
    test.measurements.power_good = result
    if result != "PASS":
        return PhaseResult.STOP


@htf.measures(
    htf.Measurement("firmware_version").equals("3.1.0"),
)
def phase_firmware(test):
    """Second highest failure rate. Run next."""
    test.measurements.firmware_version = "3.1.0"


@htf.measures(
    htf.Measurement("output_voltage_V")
    .in_range(minimum=4.9, maximum=5.1)
    .with_units(units.VOLT),
)
def phase_output(test):
    """Rarely fails. Run last."""
    test.measurements.output_voltage_V = 5.01

Step 2: Skip Redundant Tests

If a test phase has had 0% failure rate for the last 10,000 units, consider removing it from the sequence. Use TofuPilot's failure Pareto to identify these phases.

@htf.measures(
    htf.Measurement("communication_check").equals("PASS"),
)
def phase_communication(test):
    """0.01% failure rate. Candidate for skip on mature products."""
    test.measurements.communication_check = "PASS"

The decision to skip should be data-driven. TofuPilot tracks failure rates per test step. Open the Analytics tab to see which phases have zero or near-zero failure rates across thousands of units.

Step 3: Log Results for Continuous Learning

Adaptive testing requires continuous data collection. Even when you skip a test on most units, run the full sequence on a sample to validate that the skipped tests are still passing.

from tofupilot.openhtf import TofuPilot

test = htf.Test(
    phase_power_check,
    phase_firmware,
    phase_output,
    phase_communication,
)

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

Risks and Safeguards

Adaptive testing is not about testing less. It's about testing smarter. The goal is to maintain the same defect detection rate with less time and cost.