Part 14: Production & Supply Chain

Introduction to Hardware Production

Moving a product from the lab bench to the factory floor is one of the most challenging transitions in hardware engineering. A prototype that works perfectly on your desk can fail spectacularly at scale — solder joints crack, components go out of stock, and assembly tolerances stack up in unexpected ways. This part covers the systematic process of scaling your embedded hardware from a single working prototype to thousands of units shipping to customers.

New Product Introduction (NPI) Process

The NPI process is the structured framework that takes your validated prototype through increasingly rigorous stages until it’s ready for full-scale manufacturing. Each stage increases volume while tightening quality requirements.

flowchart LR
    A["Prototype
Bench Build"] --> B["EVT
5-20 units"]
    B --> C["DVT
20-100 units"]
    C --> D["Certification
CE/FCC/UL"]
    D --> E["PVT
100-500 units"]
    E --> F["MP
1000+ units"]
    B -.->|Design fixes| B
    C -.->|Reliability fails| B
    E -.->|Yield issues| C
                            

BOM Cost Optimization

# BOM cost analysis — component cost breakdown at different volumes
# Demonstrates volume pricing impact on total BOM cost

bom_items = [
    {"ref": "U1",  "desc": "STM32F411CEU6 MCU",      "qty": 1, "price_1k": 3.20, "price_10k": 2.65, "price_100k": 2.10},
    {"ref": "U2",  "desc": "LM75 Temp Sensor",        "qty": 1, "price_1k": 0.85, "price_10k": 0.62, "price_100k": 0.45},
    {"ref": "U3",  "desc": "W25Q128 Flash 16MB",      "qty": 1, "price_1k": 1.50, "price_10k": 1.15, "price_100k": 0.88},
    {"ref": "U4",  "desc": "TPS63020 Buck-Boost",     "qty": 1, "price_1k": 2.10, "price_10k": 1.75, "price_100k": 1.40},
    {"ref": "U5",  "desc": "ESP32-C3 Wi-Fi/BLE",      "qty": 1, "price_1k": 1.80, "price_10k": 1.45, "price_100k": 1.10},
    {"ref": "J1",  "desc": "USB-C Connector",          "qty": 1, "price_1k": 0.45, "price_10k": 0.32, "price_100k": 0.22},
    {"ref": "Passives", "desc": "R/C/L (52 pieces)",   "qty": 52,"price_1k": 0.008,"price_10k": 0.005,"price_100k": 0.003},
    {"ref": "PCB", "desc": "4-layer FR4 50x40mm",      "qty": 1, "price_1k": 1.80, "price_10k": 0.95, "price_100k": 0.55},
]

print("BOM Cost Analysis — IoT Sensor Node")
print("=" * 80)
print(f"{'Ref':>8} | {'Description':>24} | {'Qty':>3} | {'@1k':>7} | {'@10k':>7} | {'@100k':>7}")
print("-" * 80)

totals = {"1k": 0, "10k": 0, "100k": 0}
for item in bom_items:
    ext_1k = item["qty"] * item["price_1k"]
    ext_10k = item["qty"] * item["price_10k"]
    ext_100k = item["qty"] * item["price_100k"]
    totals["1k"] += ext_1k
    totals["10k"] += ext_10k
    totals["100k"] += ext_100k
    print(f"{item['ref']:>8} | {item['desc']:>24} | {item['qty']:>3} | ${ext_1k:>5.2f} | ${ext_10k:>5.2f} | ${ext_100k:>5.2f}")

print("-" * 80)
print(f"{'TOTAL BOM':>37} | ${totals['1k']:>5.2f} | ${totals['10k']:>5.2f} | ${totals['100k']:>5.2f}")
savings = (1 - totals["100k"] / totals["1k"]) * 100
print(f"\nVolume savings (1k → 100k): {savings:.0f}%")
print(f"Assembly cost (estimate): $1.50/unit @1k, $0.80/unit @100k")

BOM Cost Analysis — IoT Sensor Node
================================================================================
     Ref |              Description | Qty |    @1k |   @10k |  @100k
--------------------------------------------------------------------------------
      U1 |       STM32F411CEU6 MCU |   1 | $3.20 | $2.65 | $2.10
      U2 |        LM75 Temp Sensor |   1 | $0.85 | $0.62 | $0.45
      U3 |      W25Q128 Flash 16MB |   1 | $1.50 | $1.15 | $0.88
      U4 |     TPS63020 Buck-Boost |   1 | $2.10 | $1.75 | $1.40
      U5 |      ESP32-C3 Wi-Fi/BLE |   1 | $1.80 | $1.45 | $1.10
      J1 |         USB-C Connector |   1 | $0.45 | $0.32 | $0.22
 Passives |     R/C/L (52 pieces)  |  52 | $0.42 | $0.26 | $0.16
     PCB |   4-layer FR4 50x40mm  |   1 | $1.80 | $0.95 | $0.55
--------------------------------------------------------------------------------
                        TOTAL BOM  | $12.12 | $9.15 | $6.86

Volume savings (1k → 100k): 43%
Assembly cost (estimate): $1.50/unit @1k, $0.80/unit @100k

Cost Reduction Strategies

BOM cost optimization is an ongoing process, not a one-time event. Experienced hardware teams revisit their BOM every quarter to capture new savings opportunities.

Contract Manufacturer Selection

Supply Chain Strategy

# Supply chain risk assessment — single-source vs multi-source analysis
# Evaluate component supply risk for critical parts

components = [
    {"part": "STM32F411CEU6",  "sources": 1, "lead_wk": 16, "stock": "Low",  "alt": "STM32F401CEU6"},
    {"part": "ESP32-C3-MINI",  "sources": 2, "lead_wk": 12, "stock": "Med",  "alt": "ESP32-C3-WROOM"},
    {"part": "TPS63020DSJR",   "sources": 1, "lead_wk": 20, "stock": "Low",  "alt": "TPS63802"},
    {"part": "LM75BIMM",       "sources": 3, "lead_wk": 8,  "stock": "High", "alt": "TMP102"},
    {"part": "W25Q128JVSIQ",   "sources": 2, "lead_wk": 10, "stock": "Med",  "alt": "GD25Q128E"},
    {"part": "USB-C 16pin",    "sources": 5, "lead_wk": 4,  "stock": "High", "alt": "Generic"},
]

print("Supply Chain Risk Assessment")
print("=" * 85)
print(f"{'Part Number':>18} | {'Src':>3} | {'Lead':>6} | {'Stock':>5} | {'Risk':>8} | {'Alternate Part'}")
print("-" * 85)

for c in components:
    # Risk score: fewer sources + longer lead time + low stock = higher risk
    risk_score = (4 - min(c["sources"], 3)) * 2
    risk_score += max(0, c["lead_wk"] - 8) // 4
    risk_score += {"High": 0, "Med": 1, "Low": 3}[c["stock"]]

    if risk_score >= 6:
        risk = "HIGH"
    elif risk_score >= 3:
        risk = "MEDIUM"
    else:
        risk = "LOW"

    print(f"{c['part']:>18} | {c['sources']:>3} | {c['lead_wk']:>3} wk | {c['stock']:>5} | {risk:>8} | {c['alt']}")

print("\nMitigation strategies:")
print("  HIGH risk: Qualify alternate, maintain 12-week buffer stock")
print("  MEDIUM risk: Establish second source, 8-week buffer")
print("  LOW risk: Standard ordering, 4-week buffer")

Supply Chain Risk Assessment
=====================================================================================
        Part Number | Src |   Lead | Stock |     Risk | Alternate Part
-------------------------------------------------------------------------------------
   STM32F411CEU6   |   1 |  16 wk |   Low |     HIGH | STM32F401CEU6
   ESP32-C3-MINI   |   2 |  12 wk |   Med |   MEDIUM | ESP32-C3-WROOM
   TPS63020DSJR    |   1 |  20 wk |   Low |     HIGH | TPS63802
   LM75BIMM        |   3 |   8 wk |  High |      LOW | TMP102
   W25Q128JVSIQ    |   2 |  10 wk |   Med |   MEDIUM | GD25Q128E
   USB-C 16pin     |   5 |   4 wk |  High |      LOW | Generic

Mitigation strategies:
  HIGH risk: Qualify alternate, maintain 12-week buffer stock
  MEDIUM risk: Establish second source, 8-week buffer
  LOW risk: Standard ordering, 4-week buffer

Production Logistics & Yield Management

Once your CM is producing boards, yield management becomes critical. Yield is the percentage of units that pass all tests on the first attempt. Even a 1% yield drop on a 10,000-unit run means 100 boards need rework or scrap.

flowchart LR
    A["Solder Paste
Print"] --> B["Component
Placement"]
    B --> C["Reflow
Oven"]
    C --> D["AOI
Inspection"]
    D --> E["ICT/FCT
Testing"]
    E --> F["Flash &
Calibrate"]
    F --> G["Final QC
Packaging"]
    D -.->|"Defect"| H["Rework
Station"]
    H -.-> D
    E -.->|"Fail"| I["Debug &
Root Cause"]
    I -.-> H
                            

# Yield analysis — calculate production costs with different yield rates
# Shows financial impact of yield improvement

def calculate_production_cost(volume, bom_cost, assembly_cost, test_cost, yield_rate, nre_cost):
    """Calculate total and per-unit production cost including yield losses."""
    good_units = int(volume * yield_rate)
    scrap_units = volume - good_units
    
    total_material = volume * bom_cost           # Pay for ALL boards (good + scrap)
    total_assembly = volume * assembly_cost       # Assemble ALL boards
    total_test = volume * test_cost               # Test ALL boards
    rework_cost = scrap_units * (assembly_cost * 0.5)  # Rework ~50% of failures
    
    total_cost = total_material + total_assembly + total_test + rework_cost + nre_cost
    cost_per_good_unit = total_cost / good_units
    
    return {
        "good_units": good_units,
        "scrap": scrap_units,
        "total_cost": total_cost,
        "unit_cost": cost_per_good_unit
    }

# Compare yield scenarios for 5,000 unit production run
print("Yield Impact Analysis — 5,000 Unit Run")
print("=" * 65)
print(f"{'Yield':>8} | {'Good':>6} | {'Scrap':>5} | {'Total Cost':>12} | {'Per Unit':>9}")
print("-" * 65)

for yield_pct in [0.92, 0.95, 0.97, 0.99]:
    result = calculate_production_cost(
        volume=5000, bom_cost=9.15, assembly_cost=1.20,
        test_cost=0.50, yield_rate=yield_pct, nre_cost=5000
    )
    print(f"{yield_pct:>7.0%} | {result['good_units']:>5,} | {result['scrap']:>5} "
          f"| ${result['total_cost']:>10,.2f} | ${result['unit_cost']:>7.2f}")

print(f"\nImproving yield from 92% to 99% saves "
      f"${calculate_production_cost(5000,9.15,1.20,0.50,0.92,5000)['unit_cost'] - calculate_production_cost(5000,9.15,1.20,0.50,0.99,5000)['unit_cost']:.2f}/unit")

Yield Impact Analysis — 5,000 Unit Run
=================================================================
   Yield |   Good | Scrap |   Total Cost |  Per Unit
-----------------------------------------------------------------
     92% | 4,600 |   400 |   $59,540.00 |   $12.94
     95% | 4,750 |   250 |   $59,400.00 |   $12.51
     97% | 4,850 |   150 |   $59,340.00 |   $12.23
     99% | 4,950 |    50 |   $59,280.00 |   $11.98

Improving yield from 92% to 99% saves $0.97/unit

Quality Control & Inspection

Practice Exercises

Conclusion & Next Steps

Transitioning from prototype to production requires careful planning across component sourcing, manufacturer selection, quality systems, and cost management. The NPI process — EVT, DVT, PVT, MP — provides a structured framework for scaling without sacrificing quality. Remember that production is not just about building boards — it’s about building a repeatable, scalable system where every unit meets the same standard as your first working prototype.