What Is IQC, IPQC, FQC, and OQC

What Is IQC, IPQC, FQC, and OQC with TofuPilot

Manufacturing quality control happens at four stages: incoming (IQC), in-process (IPQC), final (FQC), and outgoing (OQC). Each stage catches different types of defects at different costs. This guide covers what each stage involves, what it catches, and how to track quality data across all stages with TofuPilot.

The Four Quality Gates

Stage	Full Name	When	What It Catches
IQC	Incoming Quality Control	Materials arrive	Bad components, wrong parts, supplier issues
IPQC	In-Process Quality Control	During manufacturing	Process drift, assembly errors, contamination
FQC	Final Quality Control	After assembly complete	Functional failures, cosmetic defects
OQC	Outgoing Quality Control	Before shipment	Packaging damage, labeling errors, sampling verification

Each stage is a gate. Material that fails a gate gets quarantined, reworked, or rejected. Material that passes moves to the next stage.

IQC: Incoming Quality Control

IQC inspects raw materials and components when they arrive from suppliers. It prevents bad inputs from entering the production line.

Check	Method
Visual inspection	Packaging damage, correct labels, moisture indicators
Dimensional check	Caliper or CMM measurement against drawing
Electrical sample test	Measure key parameters on a sample (AQL-based)
Certificate review	Verify CoC, RoHS compliance, lot codes

IQC sampling follows AQL (Acceptable Quality Limit) tables. You don't test every component. You test a statistically valid sample and accept or reject the lot.

IPQC: In-Process Quality Control

IPQC monitors the manufacturing process while it's running. It catches drift before it produces a batch of defective units.

Check	Method
SPI after paste printing	Automated solder paste volume measurement
AOI after reflow	Automated optical inspection of solder joints
First piece inspection	Full check of the first unit after setup
Hourly spot checks	Operator verifies key dimensions or parameters
Process parameter monitoring	Temperature, pressure, speed within control limits

IPQC is where SPC (statistical process control) lives. Control charts track process parameters in real time and flag out-of-control conditions before they produce defects.

FQC: Final Quality Control

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

Check	Method
Functional test	Automated test (ATE) against design spec
Safety test	Hipot, ground continuity, leakage current
Cosmetic inspection	Visual check for scratches, dents, label alignment
Calibration verification	Confirm calibrated parameters are within spec

FQC is typically 100% inspection for critical tests and sample-based for cosmetic checks.

OQC: Outgoing Quality Control

OQC is the final check before the product ships. It verifies that packing, labeling, and quantity are correct, and runs a final sample test.

Check	Method
Packaging integrity	Box condition, cushioning, moisture barrier
Label verification	Part number, serial, lot, regulatory marks
Quantity count	Matches packing list and order
Sample retest	Pull samples and rerun functional test

OQC is the last chance to catch problems. A failure here is expensive because the product is fully packaged and ready to ship.

Prerequisites

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

Step 1: Log Quality Checks at Each Stage

Create separate test procedures for each quality stage. This keeps the data organized and lets you track yield per stage independently.

iqc_check.py

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("component_resistance_ohm")
    .in_range(minimum=4700, maximum=5100)
    .with_units(units.OHM),
    htf.Measurement("visual_inspection").equals("PASS"),
)
def phase_iqc_sample(test):
    """IQC sample test for incoming resistor lot."""
    test.measurements.component_resistance_ohm = 4850
    test.measurements.visual_inspection = "PASS"

fqc_test.py

import openhtf as htf
from 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("safety_hipot").equals("PASS"),
)
def phase_fqc(test):
    """FQC: functional and safety test on finished unit."""
    test.measurements.output_voltage_V = 5.01
    test.measurements.safety_hipot = "PASS"

Step 2: Connect Each Stage to TofuPilot

Each quality stage uploads results independently. TofuPilot links them by serial number, giving you full traceability from incoming materials to outgoing product.

fqc_test.py

from tofupilot.openhtf import TofuPilot

test = htf.Test(phase_fqc)

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

Step 3: Track Quality Across All Stages

TofuPilot tracks results from all quality stages. Open the Analytics tab to see:

Yield per stage (IQC, IPQC, FQC, OQC separately)
Failure Pareto per stage showing top defect types
Supplier quality by tracking IQC rejection rates per vendor
Full traceability from incoming lot to shipped unit