| name | automotive-supply-chain |
| description | When the user wants to optimize automotive manufacturing supply chains, manage tier suppliers, implement JIT production, or handle automotive-specific logistics. Also use when the user mentions "automotive manufacturing," "OEM supply chain," "tier 1/2/3 suppliers," "sequenced parts delivery," "just-in-time automotive," "vehicle assembly," or "automotive aftermarket." For general manufacturing, see production-scheduling. For lean principles, see lean-manufacturing. |
Automotive Supply Chain
You are an expert in automotive supply chain management and manufacturing operations. Your goal is to help optimize complex multi-tier supply networks, implement just-in-time delivery, manage supplier relationships, and ensure efficient vehicle assembly operations.
Initial Assessment
Before optimizing automotive supply chains, understand:
-
Manufacturing Context
- OEM, Tier 1, Tier 2, or Tier 3 supplier?
- Product types? (vehicles, engines, transmissions, components)
- Production volume? (high-volume, low-volume, custom)
- Manufacturing approach? (make-to-stock, make-to-order, configure-to-order)
- Number of platforms/models?
-
Supply Chain Structure
- How many tier suppliers?
- Geographic footprint? (local, regional, global)
- Sole source vs. multi-source strategy?
- In-house vs. outsourced components?
- Vertical integration level?
-
Current State
- Inventory turns?
- Supplier quality metrics (PPM defects)?
- On-time delivery performance?
- Line stoppage frequency?
- Supply chain costs as % of revenue?
-
Business Drivers
- Cost reduction targets?
- New model launches?
- Electrification strategy (EV transition)?
- Reshoring or nearshoring plans?
- Sustainability goals?
Automotive Supply Chain Framework
Tier Structure
Multi-Tier Supplier Network:
OEM (Vehicle Manufacturer)
↑
Tier 1 (System Integrators)
↑ ↑ ↑
Tier 2 (Component Suppliers)
↑ ↑ ↑ ↑
Tier 3 (Raw Materials, Basic Parts)
Tier Definitions:
-
OEM (Original Equipment Manufacturer): Ford, GM, Toyota, VW, Tesla
- Final vehicle assembly
- Design and engineering
- Brand ownership
- Dealer network management
-
Tier 1 Suppliers: Bosch, Continental, Denso, Magna
- Major systems and modules (seats, cockpit, powertrain)
- Direct delivery to OEM assembly lines
- Often sequenced or just-in-time
- Design and engineering capability
-
Tier 2 Suppliers: Component manufacturers
- Individual parts and subassemblies
- Supply to Tier 1
- More standardized products
- Limited design input
-
Tier 3 Suppliers: Raw materials and commodities
- Steel, aluminum, plastics, electronics
- Supply to Tier 2 (sometimes Tier 1)
- Highly commoditized
Just-In-Time (JIT) and Sequencing
JIT Delivery Model
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
class AutomotiveJITScheduler:
"""
Manage Just-In-Time delivery schedules for automotive assembly
"""
def __init__(self, assembly_schedule, takt_time_minutes):
"""
Initialize JIT scheduler
Parameters:
- assembly_schedule: vehicle build schedule
- takt_time_minutes: time per vehicle (e.g., 60 seconds = 1 vehicle/min)
"""
self.assembly_schedule = assembly_schedule
self.takt_time = takt_time_minutes
def calculate_part_requirements(self, bom_df):
"""
Calculate part requirements based on assembly schedule
Parameters:
- bom_df: Bill of Materials with parts per vehicle
Returns:
- time-phased part requirements
"""
requirements = []
for idx, vehicle in self.assembly_schedule.iterrows():
build_time = vehicle['scheduled_time']
model = vehicle['model']
vin = vehicle['vin']
model_bom = bom_df[bom_df['model'] == model]
for _, part in model_bom.iterrows():
requirements.append({
'vin': vin,
'model': model,
'part_number': part['part_number'],
'quantity': part['quantity_per_vehicle'],
: build_time,
: part[],
: part[]
})
pd.DataFrame(requirements)
():
call_offs = []
grouped = part_requirements.groupby([, ])
(supplier, part_number), group grouped:
group = group.sort_values()
lead_time = group[].iloc[]
idx, row group.iterrows():
required_time = row[]
delivery_time = required_time - timedelta(hours=lead_time + buffer_hours)
call_offs.append({
: supplier,
: part_number,
: row[],
: row[],
: delivery_time,
: required_time,
: ._assign_dock_door(supplier)
})
call_off_df = pd.DataFrame(call_offs)
call_off_df.sort_values()
():
((supplier) % ) +
():
inventory_profile = []
current_inventory =
time_periods = pd.date_range(
start=call_offs[].(),
end=call_offs[].(),
freq=
)
t time_periods:
deliveries = call_offs[call_offs[] == t][].()
current_inventory += deliveries
current_inventory -= consumption_rate
inventory_profile.append({
: t,
: (, current_inventory),
: deliveries
})
pd.DataFrame(inventory_profile)
assembly_schedule = pd.DataFrame({
: [, , ],
: [, , ],
: pd.to_datetime([
,
,
])
})
bom = pd.DataFrame({
: [, , ],
: [, , ],
: [, , ],
: [, , ],
: [, , ]
})
scheduler = AutomotiveJITScheduler(assembly_schedule, takt_time_minutes=)
requirements = scheduler.calculate_part_requirements(bom)
call_offs = scheduler.generate_supplier_call_off(requirements, buffer_hours=)
()
(call_offs[[, , , ]])
Sequenced Parts Delivery
What is Sequencing?
- Parts delivered in exact build sequence
- Example: Seats delivered in order 1-2-3 matching VINs
- Eliminates sorting at assembly line
- Requires tight coordination with supplier
class SequencedPartsManager:
"""
Manage sequenced parts delivery (e.g., seats, cockpits)
"""
def __init__(self, build_sequence):
self.build_sequence = build_sequence
def generate_sequenced_order(self, part_specs):
"""
Generate sequenced parts order matching build sequence
Parameters:
- part_specs: specifications for each vehicle (e.g., seat color/material)
Returns:
- sequenced order for supplier
"""
sequenced_order = []
for idx, vehicle in self.build_sequence.iterrows():
vin = vehicle['vin']
model = vehicle['model']
spec = part_specs[part_specs['vin'] == vin].iloc[0]
sequenced_order.append({
'sequence_number': idx + 1,
'vin': vin,
'model': model,
'part_spec': spec['specification'],
'color': spec['color'],
'material': spec['material'],
'delivery_time': vehicle['scheduled_time'] - timedelta(hours=2)
})
return pd.DataFrame(sequenced_order)
def validate_sequence(self, delivered_sequence, expected_sequence):
"""
Validate delivered parts match expected sequence
Returns:
- sequence accuracy and errors
"""
errors = []
i, (delivered, expected) ((delivered_sequence, expected_sequence)):
delivered[] != expected[]:
errors.append({
: i + ,
: expected[],
: delivered[],
:
})
delivered[] != expected[]:
errors.append({
: i + ,
: delivered[],
: expected[],
: delivered[],
:
})
accuracy = - ((errors) / (expected_sequence))
{
: accuracy * ,
: errors,
: (errors)
}
Supplier Quality Management
PPM (Parts Per Million) Defect Tracking
class AutomotiveQualityManager:
"""
Track supplier quality performance (PPM defects)
"""
def __init__(self, target_ppm=50):
"""
Initialize quality manager
Parameters:
- target_ppm: target defect rate (parts per million)
"""
self.target_ppm = target_ppm
self.quality_data = []
def record_receipt(self, receipt_data):
"""Record parts receipt and inspection"""
self.quality_data.append(receipt_data)
def calculate_supplier_ppm(self, supplier=None, time_period_days=90):
"""
Calculate PPM for supplier(s)
Parameters:
- supplier: specific supplier (None = all)
- time_period_days: rolling time period
Returns:
- PPM metrics by supplier
"""
df = pd.DataFrame(self.quality_data)
cutoff_date = datetime.now() - timedelta(days=time_period_days)
df = df[df['receipt_date'] >= cutoff_date]
if supplier:
df = df[df['supplier'] == supplier]
supplier_ppm = df.groupby('supplier').agg({
'quantity_received': 'sum',
'quantity_defective': 'sum'
})
supplier_ppm['ppm'] = (
supplier_ppm['quantity_defective'] /
supplier_ppm['quantity_received'] *
)
supplier_ppm[] = supplier_ppm[] <= .target_ppm
supplier_ppm.sort_values(, ascending=)
():
ppm_data = .calculate_supplier_ppm()
critical_suppliers = ppm_data[ppm_data[] > .target_ppm * ]
warning_suppliers = ppm_data[
(ppm_data[] > .target_ppm) &
(ppm_data[] <= .target_ppm * )
]
{
: critical_suppliers,
: warning_suppliers,
: (ppm_data),
: (ppm_data[ppm_data[]]),
: (ppm_data[ppm_data[]]) / (ppm_data) *
}
():
car = {
: ,
: supplier,
: datetime.now(),
: issue_description,
: .calculate_supplier_ppm(supplier)[].iloc[],
: .target_ppm,
: [
,
,
,
],
:
}
car
qm = AutomotiveQualityManager(target_ppm=)
qm.record_receipt({
: datetime.now() - timedelta(days=),
: ,
: ,
: ,
:
})
qm.record_receipt({
: datetime.now() - timedelta(days=),
: ,
: ,
: ,
:
})
ppm = qm.calculate_supplier_ppm()
()
(ppm)
issues = qm.identify_quality_issues()
()
EV Supply Chain Considerations
Electric Vehicle Transition
Supply Chain Differences:
Traditional ICE (Internal Combustion Engine) Vehicle:
- ~30,000 parts
- Complex powertrain (engine, transmission, exhaust)
- Mature supplier base
- Established processes
Electric Vehicle (EV):
- ~20,000 parts (simpler)
- Battery pack (40-50% of vehicle cost)
- Electric motors and inverters
- New supplier base
- Battery supply chain critical
class EVSupplyChainAnalyzer:
"""
Analyze EV vs. ICE supply chain differences
"""
def __init__(self):
self.ice_bom_cost = 25000
self.ev_bom_cost = 35000
def compare_cost_structures(self):
"""Compare ICE vs. EV cost structures"""
ice_structure = {
'powertrain': 0.25,
'body_chassis': 0.30,
'electronics': 0.15,
'interior': 0.20,
'other': 0.10
}
ev_structure = {
'battery_pack': 0.40,
'electric_motor': 0.05,
'power_electronics': 0.10,
'body_chassis': 0.25,
'electronics': 0.10,
'interior': 0.08,
'other': 0.02
}
comparison = pd.DataFrame({
'ICE_pct': ice_structure,
'EV_pct': ev_structure,
'ICE_cost': {k: v * .ice_bom_cost k, v ice_structure.items()},
: {k: v * .ev_bom_cost k, v ev_structure.items()}
})
comparison
():
cell_chemistry == :
materials = {
: ,
: ,
: ,
: ,
: ,
: ,
:
}
cell_chemistry == :
materials = {
: ,
: ,
: ,
: ,
: ,
:
}
total_materials = {
material: amount * battery_capacity_kwh
material, amount materials.items()
}
material_costs = {
: ,
: ,
: ,
: ,
: ,
: ,
: ,
: ,
:
}
total_material_cost = (
total_materials.get(mat, ) * cost
mat, cost material_costs.items()
)
{
: battery_capacity_kwh,
: cell_chemistry,
: total_materials,
: total_material_cost,
: total_material_cost / battery_capacity_kwh
}
analyzer = EVSupplyChainAnalyzer()
cost_comparison = analyzer.compare_cost_structures()
()
(cost_comparison)
battery_analysis = analyzer.analyze_battery_supply_chain(
battery_capacity_kwh=,
cell_chemistry=
)
()
()
()
()
Automotive-Specific Performance Metrics
Key Performance Indicators
class AutomotiveKPITracker:
"""
Track automotive supply chain KPIs
"""
def __init__(self):
self.kpis = {}
def calculate_inventory_turns(self, annual_cogs, avg_inventory):
"""Inventory turnover (target: 15-20 for automotive)"""
turns = annual_cogs / avg_inventory
self.kpis['inventory_turns'] = turns
return turns
def calculate_dock_to_dock_time(self, total_cycle_time_hours):
"""Dock-to-dock time (supplier dock to customer dock)"""
self.kpis['dock_to_dock_hours'] = total_cycle_time_hours
return total_cycle_time_hours
def calculate_otd(self, on_time_deliveries, total_deliveries):
"""On-Time Delivery (target: >99%)"""
otd = on_time_deliveries / total_deliveries * 100
self.kpis['otd_pct'] = otd
return otd
def calculate_line_stoppage_rate(self, stoppages, production_hours):
"""Line stoppages per 1000 production hours"""
rate = (stoppages / production_hours) * 1000
self.kpis['line_stoppage_per_1000hrs'] = rate
return rate
def generate_scorecard(self, benchmarks):
scorecard = []
kpi, value .kpis.items():
benchmark = benchmarks.get(kpi, {})
benchmark:
benchmark benchmark[]:
status = value >= benchmark[]
:
status = value <= benchmark[]
:
status =
scorecard.append({
: kpi,
: value,
: benchmark.get(, ),
: status
})
pd.DataFrame(scorecard)
tracker = AutomotiveKPITracker()
tracker.calculate_inventory_turns(annual_cogs=, avg_inventory=)
tracker.calculate_otd(on_time_deliveries=, total_deliveries=)
tracker.calculate_line_stoppage_rate(stoppages=, production_hours=)
benchmarks = {
: {: , : },
: {: , : },
: {: , : }
}
scorecard = tracker.generate_scorecard(benchmarks)
()
(scorecard)
Tools & Technologies
Automotive Supply Chain Software
Tier 1 Supplier Management:
- SAP Automotive: Integrated supply chain for automotive
- Oracle E-Business Suite: Automotive-specific modules
- Kinaxis RapidResponse: S&OP for automotive
- Blue Yonder: Supply chain planning and execution
- Coupa Supply Chain Design: Network optimization
Supplier Collaboration:
- SupplyOn: Automotive supplier network (BMW, VW, Continental)
- Elemica: Supply chain collaboration
- E2open: Multi-tier visibility
- Llamasoft: Supply chain modeling
Quality Management:
- IQMS: Manufacturing ERP with quality
- TrackWise: Quality and compliance
- MasterControl: Supplier quality management
- ETQ Reliance: CAPA and quality
Python Libraries
from pulp import *
import pyomo.environ as pyo
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression
Common Challenges & Solutions
Challenge: Single-Source Supply Risk
Problem:
- Critical part from single supplier
- Plant shutdown if supplier fails
- High negotiating leverage for supplier
Solutions:
- Dual-source strategy (at least 30/70 split)
- Safety stock for critical parts
- Supplier financial monitoring
- Contract manufacturing agreements
- Vertical integration for critical components
Challenge: Long Lead Times for New Tools/Dies
Problem:
- Tooling lead times 6-12 months
- Delays new model launches
- High capital costs
Solutions:
- Early supplier involvement (ESI)
- Concurrent engineering
- Rapid prototyping and testing
- Modular tooling design
- Digital simulation before physical tooling
Challenge: Managing 1,000+ Suppliers
Problem:
- Complexity managing multi-tier network
- Lack of visibility to Tier 2/3
- Quality issues from sub-tier
Solutions:
- Supplier tiering and segmentation
- Multi-tier visibility platforms
- Supplier scorecards and audits
- Supplier development programs
- Strategic supplier reductions (consolidation)
Challenge: EV Battery Supply Constraints
Problem:
- Limited battery cell production capacity
- Competition for lithium, cobalt, nickel
- Price volatility
- Geographic concentration (China)
Solutions:
- Long-term supply agreements (offtake contracts)
- Vertical integration (own battery plants)
- Diversify cell suppliers and chemistries
- Recycling programs (circular economy)
- Alternative chemistries (LFP, solid-state)
Output Format
Automotive Supply Chain Report
Executive Summary:
- Plant: Detroit Assembly (Model A, Model B)
- Daily Production: 1,000 vehicles
- Tier 1 Suppliers: 120
- Inventory Turns: 18.5 (target: 15+)
- OTD Performance: 98.5% (target: 99%)
- Quality: 42 PPM (target: <50 PPM)
- Line Stoppages: 2.1 per 1000 hrs (target: <3)
Supply Chain Performance:
| Metric | Actual | Target | Status |
|---|
| Inventory Turns | 18.5 | 15+ | ✓ Green |
| OTD% | 98.5% | 99% | ⚠ Yellow |
| Quality (PPM) | 42 | <50 | ✓ Green |
| Line Stoppages | 2.1 | <3 | ✓ Green |
| Dock-to-Dock Time | 4.2 hrs | <6 hrs | ✓ Green |
Supplier Quality (Top Issues):
| Supplier | Part | PPM | Status | Action |
|---|
| Supplier_X | PART_123 | 285 | Critical | CAR issued |
| Supplier_Y | PART_456 | 110 | Warning | Under review |
| Supplier_Z | PART_789 | 45 | Good | Monitor |
JIT Delivery Performance:
| Supplier | Deliveries | On-Time | Early | Late | Performance |
|---|
| Supplier_A | 250 | 248 | 1 | 1 | 99.2% |
| Supplier_B | 180 | 175 | 3 | 2 | 97.2% |
| Supplier_C | 300 | 300 | 0 | 0 | 100% |
Action Items:
- Address Supplier_X quality issue (285 PPM) - CAR in progress
- Improve OTD from 98.5% to 99% - focus on 3 underperforming suppliers
- Complete EV battery supplier qualification for Model C launch
- Implement Tier 2 visibility platform for critical components
Questions to Ask
If you need more context:
- OEM or Tier 1/2/3 supplier?
- What products/components are manufactured?
- Production volume and model complexity?
- Current supply chain structure and key metrics?
- JIT delivery in place?
- Supplier quality performance (PPM)?
- Any EV products or transition plans?
- Major supply chain challenges or pain points?
Related Skills
- production-scheduling: For assembly line scheduling
- lean-manufacturing: For waste elimination and continuous improvement
- capacity-planning: For production capacity management
- supplier-selection: For supplier evaluation and qualification
- supplier-risk-management: For supply continuity
- quality-management: For quality systems and SPC
- inventory-optimization: For safety stock and inventory policies
- master-production-scheduling: For MPS development
- demand-forecasting: For production planning
