DFT · Chapter 1 · Manufacturing Test Mindset
Yield, Escape Rate & Test Economics
This lesson gives you the economic vocabulary a test engineer lives by. Yield is the fraction of manufactured dies that are actually good, and it is a property of the fab, not the tester. Test does not create yield; it sorts good dies from defective ones so you only ship the good ones. An escape is a defective die that passes test and ships anyway, caused by a coverage gap, and it turns into an expensive field failure. Test can err in two directions: overkill, when a good die fails test and wastes money, and underkill, when a bad die passes test and a defect ships. Higher fault coverage drives the escape rate down. The economics are simple, because a per-die test is cheap while an escape, a return, or a recall is enormous, so test pays for itself by catching defects before they escape.
Foundation13 min readDFTYieldEscape RateTest EconomicsCoverage
Chapter 1 · Section 1.2 · Manufacturing Test Mindset
Project thread — the 4-bit counter (1.1), now manufactured as a lot of dies whose yield, escapes, and test cost we quantify.
1. Why Should I Learn This?
Manufacturing test is an economic activity, and these four words are its language:
- Yield — fraction of dies that are good (a fab property; test sorts, doesn't create it).
- Escape — a defective die that passes test (a coverage gap → field failure).
- Overkill / yield loss — a good die that fails test (wasted money).
- Underkill / escape — a bad die that passes test (shipped defect).
Every later chapter exists to push the escape rate down without wasting yield or test time.
2. Real Silicon Story — the escapes that came back
A product shipped with 95% ATPG coverage — 'good enough,' the team thought. Wafer yield was healthy, the tester passed parts quickly, everyone moved on.
Months later, field returns started arriving — customers' boards failing in ways that traced to defective dies that had passed the tester. These were escapes: real defects sitting in the 5% coverage gap — faults the patterns never exercised, so the tester saw 'pass.' Each return cost orders of magnitude more than the test would have: RMA handling, replacement, shipping, and reputational damage.
The fix wasn't a better tester — the tester was working perfectly, it just wasn't told to check those faults. The fix was more coverage (Chapter 6), bought back in the RTL and ATPG flow. Lesson: an escape is a coverage problem, and a cheap test-second is far cheaper than an expensive field return.
3. Concept — yield, escapes, and the two error directions
Yield — the fraction of manufactured dies that are good:
- It's a property of the fab and the design's manufacturability — process maturity, defect density, die size.
- Test does not improve yield. Test sorts: it identifies the defective dies so you don't ship them. (Culling bad dies raises shipped quality, but the underlying yield is what the fab produced.)
Escape — a defective die that passes test and ships:
- Cause: a coverage gap — a defect on a fault your patterns never exercised, so the tester never saw a mismatch.
- Consequence: a field failure in the customer's product — the most expensive failure mode.
The two error directions of a test:
| What happens | Name | Cost | |
|---|---|---|---|
| Overkill | A good die fails test | Yield loss / false reject | Throw away a good part |
| Underkill | A bad die passes test | Escape / false accept | Ship a defect → field failure |
- Overkill wastes yield (good money binned) — often from over-tight tester limits or bad test setup.
- Underkill is an escape — driven by low coverage. This is the dangerous one.
- Fault coverage is the main lever on escapes: higher coverage → fewer un-exercised faults → fewer escapes.
4. Mental Model — a security checkpoint
Picture an airport security checkpoint. Passengers (dies) stream through; some carry contraband (defects).
- Yield is set before the checkpoint — how many passengers are 'clean' depends on the population, not the scanner. The checkpoint can't make people clean; it only sorts them.
- A good detection stops a passenger with contraband — that's a detected defect (bin).
- An escape (underkill) is a passenger with contraband who walks through undetected — the scanner's coverage was too low (it didn't check that pocket). This is the dangerous miss; the contraband ends up downstream (field).
- Overkill is a clean passenger flagged and pulled aside — wasted effort and a wrongly-rejected traveler (yield loss).
- Economics: the scan is cheap (seconds); a contraband item reaching the plane (an escape) is catastrophic. So you buy better coverage — check more pockets per second — not a slower line.
You don't fix escapes by making the good passengers wait longer — you fix them by checking more places (coverage).
5. Working Example — yield, escapes, and cost on the counter lot
Take a lot of the project's 4-bit counter and put representative numbers on it:
# Yield / escape model — REPRESENTATIVE (a lot of 10,000 counter dies):
Fab yield = 90% -> 9,000 GOOD dies, 1,000 DEFECTIVE dies (set by the FAB)
ATPG fault coverage = 95% -> test detects 95% of the defective dies
Detected defects (bin) = 950 -> binned (yield loss you always expected)
ESCAPES (underkill) = 50 -> defective dies that PASSED (5% coverage gap) -> SHIP -> field failures
Overkill (good fails) = ~small -> good dies wrongly failed (tighten setup, not coverage)
# Raising coverage 95% -> 99% cuts escapes 50 -> 10. Test did NOT change the 90% yield; it changed how many defects ESCAPE.The cost comparison that justifies the whole activity:
# Test economics — REPRESENTATIVE (order-of-magnitude):
Cost of testing one die ~ cents (a few tester-seconds)
Cost of ONE escape in field ~ $$$$ (RMA + replace + ship + reputation; safety recall = far worse)
# 50 escapes * (field cost) >> 10,000 dies * (test cost) -> TEST PAYS FOR ITSELF by catching defects early.
# The lever on escapes is COVERAGE (Ch6), set in RTL + ATPG -- NOT the tester.6. Industry Flow — where yield and escapes are set vs measured
Yield is created at the fab; escapes are set by coverage (RTL/ATPG) and measured in the field:
7. Debugging Session — field escapes are climbing
Field returns are rising and trace to defective dies that passed the tester (escapes); the instinct is to tighten the tester or blame the fab, but escapes come from a coverage gap -- the patterns never exercised those faults -- so the fix is more fault coverage (Ch6) in RTL/ATPG, not a tighter tester or higher yield
ESCAPES = COVERAGE GAP, NOT TESTER ERROR OR LOW YIELDField returns are climbing. Analysis shows the returned parts are defective dies that passed the tester — escapes. Wafer yield looks normal; the tester is running cleanly and passing parts quickly.
Escapes come from a coverage gap, not from a broken tester or low yield. An escape is a defective die that passes test — and it passes precisely because the test patterns never exercised the fault that this die carries. The tester did exactly what it was told; it just wasn't told to check that fault. Two wrong instincts here: (1) 'tighten the tester' — but the tester isn't wrong on the parts it does check; tightening limits mostly creates overkill (good dies now failing → yield loss) without touching the un-exercised faults that actually escape. (2) 'the fab yield is bad' — but yield is separate: yield is how many dies are good, while escapes are defective dies slipping through test; you can have great yield and still have escapes if coverage is low. The real variable is fault coverage: at 95% coverage, ~5% of the defective dies carry a fault your patterns never hit, and those are your escapes. Higher coverage → fewer un-exercised faults → fewer escapes.
Raise fault coverage — the fix lives in RTL and ATPG, not on the tester. Escapes are reduced by detecting more faults: improve testability in the RTL (make uncontrollable/unobservable nodes reachable — Chapter 4/6), then let ATPG target the previously-missed faults and close coverage to the signoff target (Chapter 6). Track the result with the yield/escape report: as coverage climbs (say 95% → 99%), the escape count drops (50 → 10 per 10k in our model) — without changing the fab's yield and without tightening the tester into overkill. The economic logic seals it: a per-die test is cheap (seconds) while an escape is enormous (return/recall/field failure), so spending a little more test — bought as coverage — to catch defects before they escape always pays. Summary of the mental model to lock in: yield is a fab property (test sorts, it doesn't create yield); an escape is a defective die that passes test because of a coverage gap; overkill is a good die failing (yield loss) and underkill is a bad die passing (an escape); and coverage — set in RTL and ATPG, not the tester — is the lever that drives escapes down. (DPPM quantifies escapes-per-million in 1.5; coverage closure is Chapter 6.)
8. Common Mistakes
- Thinking test 'improves yield.' Test sorts; yield is a fab property. Test raises shipped quality by culling bad dies.
- Blaming the tester for escapes. Escapes are a coverage gap — the tester passed a fault it was never told to check.
- Tightening tester limits to stop escapes. That creates overkill (yield loss) without touching un-exercised faults.
- Confusing overkill and underkill. Overkill = good die fails (yield loss); underkill = bad die passes (escape).
- Treating 'passed test' as 'defect-free.' Below 100% coverage, passing only means the tested faults are absent.
9. Industry Best Practices
- Track escapes and overkill separately — they have different fixes (coverage vs tester setup).
- Drive escapes with coverage, set in RTL and ATPG — not with tester limits.
- Compare test cost to escape cost — a cheap test-second beats an expensive field return.
- Feed field-return data back to coverage targets (1.5, Chapter 6).
- Keep yield and escapes distinct — one is the fab's, the other is the test's coverage.
10. Senior Engineer Thinking
- Beginner: "Escapes are up — the tester must be broken, or yield dropped."
- Senior: "The tester passes what it's told to check. Escapes mean coverage is too low — defects on un-exercised faults are slipping through. Yield is a separate fab number. I raise coverage in RTL/ATPG (a cheap test-second) to stop an expensive field return — I don't tighten the tester into overkill."
The senior separates yield (fab) from escapes (coverage) and reaches for the coverage lever.
11. Silicon Impact
The escape is the most expensive failure in the whole flow, and this lesson's economics explain why every later chapter exists. A defect caught on the tester costs seconds and cents; the same defect as an escape costs a return, a replacement, shipping, and reputation — and in automotive/medical, potentially a recall or a safety event (1.5). The lever that separates those two outcomes is fault coverage, and coverage is capped by the RTL — uncontrollable or unobservable logic becomes untestable faults, which become escapes. That is the through-line of this whole curriculum: scan (Ch3), scan insertion (Ch4), ATPG (Ch5), and coverage closure (Ch6) all exist to buy coverage so defects are caught cheaply on the tester instead of expensively in the field. Meanwhile overkill (good dies failing) protects you from over-tightening the tester and throwing away yield. A test engineer who internalizes yield vs escapes vs overkill — and which lever moves each — makes the right call every time: coverage for escapes, setup for overkill, and never confuse either with the fab's yield.
12. Engineering Checklist
- Separated yield (fab) from escapes (coverage) in the analysis.
- Tracked overkill (yield loss) and underkill (escapes) as distinct metrics.
- Attacked escapes with coverage (RTL/ATPG), not tester limits.
- Compared test cost vs escape cost to justify coverage targets.
- Remembered 'passed test' ≠ 'defect-free' below 100% coverage.
13. Try Yourself
- Take a lot of 10,000 counters with 90% yield (9,000 good, 1,000 defective).
- At 95% coverage, compute detected defects (950 binned) and escapes (50 shipped).
- Raise coverage to 99% — recompute escapes (10). Note the yield stayed 90%; only escapes changed.
- Put order-of-magnitude costs on a test (cents) and an escape (dollars). Show that fewer escapes dominates the economics.
- Now tighten a tester limit so a few good dies fail — observe that's overkill (yield loss), and it didn't reduce escapes.
The arithmetic is tool-independent — a spreadsheet is enough. Coverage numbers come from any ATPG flow (Chapters 5–6). No paid tool required.
14. Interview Perspective
- Weak: "Yield is how many chips work; escapes are bad chips."
- Good: "Yield is the fraction of good dies from the fab; an escape is a defective die that passes test."
- Senior: "Yield is a fab property — the fraction of good dies — and test doesn't create it, it sorts. An escape is a defective die that passes test, caused by a coverage gap, and it becomes a field failure. Test errs two ways: overkill (a good die fails → yield loss) and underkill (a bad die passes → escape). Coverage — set in RTL and ATPG — is the lever on escapes, and since a test-second is cheap while an escape is expensive, buying coverage to catch defects early always pays."
15. Interview / Review Questions
16. Key Takeaways
- Yield is the fraction of manufactured dies that are good — a property of the fab, not the tester. Test does not create yield; it sorts good dies from defective ones.
- An escape is a defective die that passes test and ships — caused by a coverage gap (a fault never exercised) — and it becomes an expensive field failure.
- Test makes two kinds of error: overkill (a good die fails test → yield loss, false reject) and underkill (a bad die passes test → an escape, false accept).
- Fault coverage is the lever on escapes — higher coverage → fewer un-exercised faults → fewer escapes — and it's set in RTL and ATPG (Chapters 4–6), not on the tester.
- Economics: a per-die test is cheap (seconds) while an escape is enormous (return/recall) — so test pays for itself by catching defects before they escape. Next: 1.3 — where test happens: wafer, package & system-level.
17. Quick Revision
Test economics vocabulary. YIELD = fraction of GOOD dies (a FAB property; test SORTS, doesn't create it). ESCAPE = a DEFECTIVE die that PASSES test (a COVERAGE GAP → field failure). OVERKILL / yield loss = a GOOD die FAILS test (false reject). UNDERKILL / escape = a BAD die PASSES test (false accept). Coverage (RTL + ATPG, not the tester) is the lever on escapes. A test-second is CHEAP; an escape is EXPENSIVE → test pays for itself. Next: 1.3 — wafer, package & system-level test.