What Is IQC, IPQC, FQC, and OQC

Manufacturing quality control happens at four gates: incoming (IQC), in-process (IPQC), final (FQC), and outgoing (OQC). Each gate catches a different class of defect, and a defect that slips past a gate costs roughly ten times more to catch at the next one. This guide explains what each gate checks, who owns it, how sampling works, and how to track yield per gate with TofuPilot.

The Four Quality Gates

Each gate is a decision point. Material that fails is quarantined, reworked, or rejected. Material that passes moves on. The four gates together form the quality plan for a product line, and every one of them produces test data you can track.

Why the Order Matters: The Cost of Escape

The classic rule of thumb in electronics manufacturing is 1-10-100: a defect that costs 1 unit to catch at incoming inspection costs about 10 to catch during assembly and about 100 once the product is finished. A defect that reaches the customer costs far more again in returns, field service, and reputation.

Concretely, a bad capacitor lot caught at IQC means returning a reel to the supplier. The same lot caught at FQC means desoldering parts from hundreds of populated boards. Caught in the field, it means a recall.

That asymmetry is why IQC and IPQC exist at all. Nobody wants to pay for four inspections; everyone wants to avoid paying for the escape.

IQC: Incoming Quality Control

IQC inspects raw materials and components when they arrive. It keeps bad inputs out of the line before any value has been added to them.

IQC does not test every part. It follows an acceptance sampling plan, usually from ANSI/ASQ Z1.4 (the successor to MIL-STD-105E), keyed to an Acceptable Quality Limit (AQL).

AQL sampling, worked example

Say a reel of 1,000 resistors arrives and your plan is General Inspection Level II with an AQL of 1.0 %.

You measure 80 resistors. Two are out of tolerance, so the lot is accepted. Three, and the whole reel goes back. A tighter AQL (0.65 %) or a switch to Tightened inspection after repeated rejections shrinks the accept number.

Recording each sampled measurement, not just the lot verdict, is what turns IQC into a supplier scorecard. A supplier whose parts pass but trend toward the limit is a supplier about to fail.

IPQC: In-Process Quality Control

IPQC monitors the process while it runs. It catches drift before it turns into a batch of defective units.

IPQC is where statistical process control (SPC) lives. A control chart on paste volume or reflow peak temperature shows drift hours before AOI starts flagging defects. The automated inspection steps (SPI, AOI, and AXI) each produce a pass/fail per board plus measurements you can trend.

On a new line or after a design change, the first-piece check is formalised as a First Article Inspection (FAI).

FQC: Final Quality Control

FQC tests the fully assembled product against its specification. This is where functional testing, safety testing, and cosmetic inspection happen.

FQC is typically 100 % inspection for functional and safety tests, and sample-based for cosmetics. Because every unit gets a functional test here, FQC is where most of your test data volume comes from and where first pass yield is usually measured.

OQC: Outgoing Quality Control

OQC is the last check before the product ships. It verifies that what goes in the box matches the order, and pulls a sample to confirm nothing drifted between FQC and packing.

An OQC failure is expensive because the product is finished and packed. It is also a signal that FQC missed something, so an OQC failure should trigger a review of the FQC coverage, not just a rework of the lot.

OQC is a point check. For confidence that units keep working after shipment, manufacturers add ongoing reliability testing (ORT), which pulls units from the line and stress-tests them on a schedule.

Prerequisites

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

Step 1: Write One Test Procedure per Gate

Keep each gate as its own procedure. TofuPilot tracks yield per procedure, so one procedure per gate gives you IQC, IPQC, FQC, and OQC yield out of the box instead of one blended number.

import openhtf as htffrom openhtf.util import units@htf.measures(    htf.Measurement("resistance_ohm")    .in_range(minimum=4700, maximum=5100)    .with_units(units.OHM),    htf.Measurement("marking_matches_po").equals(True),)def phase_iqc_sample(test):    """IQC: one sampled resistor from the incoming reel."""    test.measurements.resistance_ohm = 4850    test.measurements.marking_matches_po = True

import openhtf as htffrom openhtf.util import units@htf.measures(    htf.Measurement("paste_volume_pct")    .in_range(minimum=80, maximum=120)    .with_units(units.PERCENT),    htf.Measurement("reflow_peak_C")    .in_range(minimum=235, maximum=250)    .with_units(units.DEGREE_CELSIUS),)def phase_ipqc_first_piece(test):    """IPQC: first piece after changeover, values from SPI and oven profiler."""    test.measurements.paste_volume_pct = 104    test.measurements.reflow_peak_C = 243

import openhtf as htffrom openhtf.util import units@htf.measures(    htf.Measurement("output_voltage_V")    .in_range(minimum=4.9, maximum=5.1)    .with_units(units.VOLT),    htf.Measurement("hipot_leakage_mA")    .in_range(maximum=0.5)    .with_units(units.MILLIAMPERE),)def phase_fqc(test):    """FQC: functional and safety test on the finished unit."""    test.measurements.output_voltage_V = 5.01    test.measurements.hipot_leakage_mA = 0.12

import openhtf as htffrom openhtf.util import units@htf.measures(    htf.Measurement("output_voltage_V")    .in_range(minimum=4.9, maximum=5.1)    .with_units(units.VOLT),    htf.Measurement("label_matches_order").equals(True),)def phase_oqc_sample(test):    """OQC: sampled unit pulled from the packed lot."""    test.measurements.output_voltage_V = 5.00    test.measurements.label_matches_order = True

The OQC procedure reuses the FQC voltage limits on purpose. If the same measurement drifts between FQC and OQC on the same serial, you have a handling or storage problem, and TofuPilot will show both runs side by side under that serial.

Step 2: Upload Every Gate to TofuPilot

Each procedure uploads independently. TofuPilot links runs by serial number, so an IQC lot, the IPQC first piece built from it, and the FQC and OQC runs on the finished unit all land on one timeline.

from tofupilot.openhtf import uploadtest = htf.Test(phase_fqc)test.add_output_callbacks(upload())test.execute(test_start=lambda: input("Scan unit serial: "))

Use the same pattern in the other three files. For IQC, scan the reel or lot ID as the serial. For IPQC, scan the first-piece board. For OQC, scan the sampled unit.

Step 3: Read Yield and Failures per Gate

With one procedure per gate, the Analytics view answers the questions each gate owner actually asks:

• Yield per gate. IQC, IPQC, FQC, and OQC each get their own first pass yield. A drop at one gate points at one team.
• Top failures per gate. A Pareto of failing measurements tells you whether FQC is failing on voltage or on hipot, and whether that changed this week.
• Supplier quality. Filter IQC runs by supplier lot to see rejection rate and measurement drift per vendor.
• Full traceability. Open any shipped serial and walk back through OQC, FQC, IPQC, and the IQC lot its components came from. See how to build full unit traceability for the sub-assembly setup.

Common Mistakes