Stress Screening (ESS): A Complete Guide

Environmental stress screening (ESS) applies a controlled stress to every production unit so that latent workmanship defects fail in the factory instead of in the field. Learn what ESS is, how it differs from HALT, HASS and qualification, how to choose stresses and levels, and how to record each screen as a TofuPilot procedure.

What ESS Is

A latent defect is a flaw that passes a functional test at ambient conditions but fails early in service: a solder joint with a crack that has not yet opened, a crimp with too few strands, a screw torqued below spec, a component with a damaged die attach. These defects come from the manufacturing process, not from the design, so they appear on some units and not others.

ESS is a production process with three properties:

The screen removes the early part of the failure rate curve (the infant mortality region) from what the customer receives. It does nothing for design weaknesses, which fail on every unit and belong to design verification.

ESS vs HALT, HASS and Qualification

Four activities use the same chambers and shakers, which is why they are often confused. They answer different questions.

HASS is a form of screening with levels derived from HALT. ESS in the broader sense covers any production screen, including programs with moderate levels set from the product specification. Both are applied to units that ship, which is the constraint that drives every choice below.

The Stresses

Three stresses carry most production screens. Each one precipitates a different family of defects.

Thermal cycling and random vibration are complementary rather than interchangeable: a defect sensitive to one is often insensitive to the other. Many programs run both, in sequence or combined in one chamber. Power cycling is usually applied during the thermal cycles so that the unit sees turn-on at hot and cold extremes.

Setting Screen Levels

The level of a screen is a trade-off between two failure modes of the screen itself: too low, and latent defects pass; too high, and good units ship with part of their life consumed, or fail outright.

Start From HALT Margins and Field Data

Two sources give a defensible starting point:

• HALT results. HALT finds the operating limits (the unit stops working, recovers when the stress is removed) and the destruct limits (permanent failure). A production screen sits inside the operating limits, with margin, so the unit can be monitored while it is stressed.
• Field returns and failure analysis. Each confirmed workmanship failure from the field names a mechanism. A cracked joint on a heavy capacitor points to vibration. A fatigue crack on a fine-pitch package points to thermal cycling.

Parameters to Fix

The product temperature is what matters. Place a thermocouple on a representative heavy component during profile development: a large heatsink or a potted assembly lags the air by minutes, and a dwell shorter than that lag means the product never reaches the setpoint.

The vibration level at the product depends on the fixture. A fixture with a resonance in the test band amplifies some frequencies and attenuates others. Survey the fixture with an accelerometer before freezing the profile.

Prove That the Screen Does Not Consume Good-Unit Life

The standard check is a proof of screen: run the complete screen many times on known-good units, then confirm with the functional test and, if possible, with an inspection or a cross-section that the units are still sound. If a good unit survives many repetitions of the screen, one application consumes a small fraction of its life. The number of repetitions is a program decision; write it down with the profile.

Screen Effectiveness

A screen is effective when the defects it is designed for both fail and get detected. The two probabilities multiply:

SE = Pp × PdPp: precipitation efficiency, probability that the stress turns a latent defect into a failurePd: detection efficiency, probability that the test detects the failure once it existsExample values: Pp = 0.8, Pd = 0.9  ->  SE = 0.72

The example shows why detection matters as much as stress. A defect that opens only while the unit is cold and vibrating is precipitated by the screen, but if the unit is tested only at ambient after the screen, Pd for that defect is close to zero.

Two production indicators tell whether the screen is set correctly:

• Fallout per cycle. Record the cycle in which each failure first appears. If failures still occur in the last cycle, the screen is too short. If no failure has appeared after the first cycles over many units, the later cycles may only consume life.
• Escapes. Workmanship failures found later (at system test or in the field) on units that passed the screen point to a defect type the screen does not precipitate or does not detect.

Functional Test Before, During and After

Each of the three test points has a different job.

Monitoring during the screen is what makes intermittent defects visible. A cracked joint can close again when the board returns to room temperature, and the post-screen test then passes a unit that will fail in service. Keep the monitoring simple and continuous: a heartbeat, a supply current, a loop-back, or a resistance measurement on the critical path.

Recording Each Screen in TofuPilot

A screen maps onto a TofuPilot procedure directly. The pre-screen test is a setup phase, the screen is a main phase that monitors the unit, the post-screen test follows it, and a teardown phase returns the chamber to ambient and switches the unit off whatever the outcome. The chamber, the power supply and the unit monitor are plugs.

The operator scans the serial number in the automatic Identify Unit step, so every result is stored against that serial number.

name: ESC Board Thermal Cycling Screenversion: 1.0.0execution:  workers: 1 # phases share the chamber and the supply, run them one at a timeplugs:  - name: Thermal Chamber    key: chamber    python: plugs.chamber:ThermalChamber    scope: station    with:      address: "{config.CHAMBER_ADDRESS}"  - name: Power Supply    key: psu    python: plugs.psu:PowerSupply    with:      address: "{config.PSU_ADDRESS}"  - name: Unit Monitor    key: monitor    python: plugs.monitor:UnitMonitorconfig:  CHAMBER_ADDRESS:    required: true  PSU_ADDRESS:    required: truesetup:  - name: Pre-Screen Functional Test    python: phases.functional:functional_test    measurements:      - name: Idle Current        unit: A        validators:          - operator: ">="            expected_value: 0.05          - operator: "<="            expected_value: 0.15main:  - name: Thermal Cycling    key: thermal_cycling    python: phases.thermal:thermal_cycling    timeout: 12h    with:      low_c: -40      high_c: 85      dwell_min: 20      cycles: 10    measurements:      - name: Cycles Completed        validators:          - operator: ">="            expected_value: 10      - name: Monitor Faults        validators:          - operator: "=="            expected_value: 0      - name: First Fault Cycle        description: 0 when no fault was detected  - name: Post-Screen Functional Test    python: phases.functional:functional_test    depends_on: [thermal_cycling]    measurements:      - name: Idle Current        unit: A        validators:          - operator: ">="            expected_value: 0.05          - operator: "<="            expected_value: 0.15teardown:  - name: Return to Ambient    python: phases.thermal:return_to_ambient

The temperatures, dwell and cycle count above are example values. Use the values your own profile development produced.

The screen phase owns the loop and the waiting. Plug methods stay short (a setpoint, a reading), because a plug runs one method call at a time and a long call would block every other caller.

import timedef thermal_cycling(chamber, psu, monitor, measurements, log, low_c, high_c, dwell_min, cycles):    faults = 0    first_fault_cycle = 0    psu.output_on()    for cycle in range(1, cycles + 1):        for setpoint in (high_c, low_c):            chamber.set_temperature(setpoint)            deadline = time.monotonic() + dwell_min * 60 + chamber.ramp_seconds(setpoint)            # Poll the unit for the whole ramp and dwell: intermittents only show here            while time.monotonic() < deadline:                if not monitor.heartbeat_ok():                    faults += 1                    if first_fault_cycle == 0:                        first_fault_cycle = cycle                    log.warning(f"Cycle {cycle}, {setpoint} C: heartbeat lost")                time.sleep(1)        log.info(f"Cycle {cycle}/{cycles} complete, faults so far: {faults}")    measurements.cycles_completed = cycles    measurements.monitor_faults = faults    measurements.first_fault_cycle = first_fault_cycledef return_to_ambient(chamber, psu):    psu.output_off()    chamber.set_temperature(25)

The chamber plug wraps the controller interface, which varies by vendor (serial, Modbus TCP, Ethernet text commands). Phases only need a few methods:

class ThermalChamber:    def __init__(self, address):        self.address = address        self.rate_c_per_min = 5.0  # example value, set from the chamber datasheet        self.current_setpoint = 25.0        # Open the controller connection here    def set_temperature(self, celsius):        # Send the setpoint to the controller        self.current_setpoint = celsius    def ramp_seconds(self, celsius):        return abs(celsius - self.current_setpoint) / self.rate_c_per_min * 60    def read_temperature(self):        # Query the controller, or a product thermocouple through a DAQ        return self.current_setpoint

A vibration screen uses the same structure with a shaker controller plug and a phase per axis, each with its own Monitor Faults measurement.

On the dashboard, the failure Pareto per measurement shows which test point finds the defects: a unit that fails Monitor Faults but passes the post-screen test is the intermittent the screen exists for. First Fault Cycle gives the fallout per cycle across units. The run history of each serial number keeps the pre-screen, screen and post-screen results together, which is what a later field return will be compared against. To decide limits on monitored values from production data, see how to set measurement limits using production data.

Common Pitfalls

Screening without monitoring. A unit tested only at ambient after the screen hides every intermittent that recovers at room temperature. Monitor during the stress.

Setting the dwell on chamber air temperature. The product lags the air. Measure the product during profile development and size the dwell from it.

Copying a profile from another product. Levels depend on mass, fixture, materials and HALT margins. A profile that is gentle for one assembly can be destructive for another.

No proof of screen. Without repeated screens on good units, nothing shows that the screen leaves shipped units with their life intact.

Treating screen fallout as a test result only. Every screen failure is a process defect with a root cause on the line. Feed it back to the process step that produced it.

Using a screen to find design weaknesses. A failure that appears on every unit is a design issue. HALT and qualification are where it belongs.

Key Points

• ESS stresses 100% of production units to precipitate latent workmanship defects before shipment.
• HALT finds design limits on prototypes, qualification proves the design, HASS and ESS screen shipped units.
• Random vibration, thermal cycling and power cycling precipitate different defect families.
• Set levels from HALT margins and field failure analysis, then prove with repeated screens that good units are not damaged.
• Screen effectiveness is precipitation efficiency times detection efficiency, so monitor the unit during the stress.
• In TofuPilot, the pre-screen test, the monitored screen and the post-screen test are phases of one procedure, recorded against the unit serial number.