Will your planned layout actually deliver target throughput? The honest answer is: nobody knows until production starts — unless you simulate it first. Layout decisions in a greenfield factory become permanent the moment equipment is bolted down, conveyors are embedded in concrete, and utility drops are positioned. Moving a machine 2 meters after installation costs $50K-$200K and 2-4 weeks of delay. Discovering a bottleneck after commissioning means months of rework and millions in lost production while the line runs at 65-70% of design capacity. Yet most US manufacturers still plan production flow in spreadsheets — calculating throughput from ideal cycle times without accounting for the variability that destroys real-world performance: changeover times that vary by product transition, random machine breakdowns, quality rework loops, material supply delays, and operator availability gaps. Research shows discrete event simulation (DES) achieves results that spreadsheets simply can't: a 29.4% increase in production capacity and 51% reduction in work-in-progress at one facility, 43% cycle time reduction per product variant at another, and 14.5% throughput improvement with 35.4% scrap reduction in coupling manufacturing. We model every workstation, buffer, conveyor, operator, and material handling system in your greenfield layout — then run thousands of simulated production hours with realistic variability to identify bottlenecks, optimize buffer sizing, balance operator workloads, and validate throughput targets before the first foundation is poured. Schedule a Demo
Why Spreadsheets Fail at Production Flow
Averages Hide Bottlenecks
A spreadsheet says "60-second average cycle time × 60 = 60 parts/hour." Reality: cycle times follow a distribution (mean 60s, std dev 8s). When WS-03 hits a 72-second cycle while WS-02 finishes in 48 seconds, the buffer overflows and WS-02 blocks. Averages predict 60 parts/hour. Simulation predicts 47 — because variability compounds across stations.
No Changeover Impact
Product A→B changeover takes 12 minutes. Product B→C takes 45 minutes. Spreadsheets calculate daily capacity assuming one changeover. Reality: 8 changeovers per shift in a high-mix environment consume 2-4 hours of productive time. Simulation models the actual changeover matrix and reveals which production sequences minimize total changeover time.
No Breakdown Effect
A machine with 98% availability "loses only 2%." But that 2% happens in chunks: one 45-minute breakdown per shift. During that 45 minutes, all downstream stations starve and all upstream stations block. The cascade effect reduces line output by 8-15% — not 2%. Simulation models MTBF/MTTR distributions and shows the real production impact of every breakdown event.
No Buffer Interaction
Without simulation, buffer sizes are guessed: "put 10 pieces between each station." In reality, the optimal buffer between stations with equal cycle times is 1-3 pieces. Between stations with unbalanced cycle times: 15-30 pieces. Between stations before and after a quality inspection gate: 50+ pieces. Wrong buffer sizing either wastes floor space or causes blocking/starvation.
Still planning production flow in spreadsheets? Schedule a demo to see how discrete event simulation reveals the bottlenecks, buffer problems, and throughput losses that spreadsheet models systematically miss.
What We Simulate
| Simulation Element | What We Model | What It Reveals | Spreadsheet Can't |
|---|---|---|---|
| Cycle Times | Statistical distribution per workstation per product (mean + std dev + min/max) | Real throughput under variability; blocking and starvation patterns | Only uses averages — misses 15-30% throughput loss from variability |
| Changeovers | Product-to-product changeover matrix (time varies by transition type) | Optimal production sequencing; total changeover time per shift | Assumes single average changeover — misses sequence-dependent losses |
| Breakdowns | MTBF/MTTR distributions per machine (Weibull, exponential) | Cascade effect of breakdowns; buffer requirements to absorb downtime | Uses availability % — misses blocking/starvation cascade |
| Buffers/WIP | Buffer capacity between every station pair; overflow/underflow behavior | Optimal buffer size; WIP inventory levels; floor space requirements | Guesses buffer sizes — either wastes space or creates bottlenecks |
| Material Handling | AGV routes, conveyor speeds, forklift paths with collision detection | Transport delays; traffic congestion; vehicle fleet sizing | Ignores transport time or uses fixed averages |
| Operators | Skill-based allocation; multi-machine tending; break/fatigue patterns | Staffing requirements by shift; workload balance; ergonomic exposure | Assumes constant operator availability — misses breaks and fatigue |
| Quality Loops | First-pass yield; rework routing; inspection station capacity | Rework impact on throughput; inspection bottleneck; scrap rates | Applies yield % at end — misses rework loop delay on main flow |
| Demand Scenarios | High/low/seasonal demand; product mix changes; rush orders | Capacity headroom; bottleneck shifts under different demand profiles | Tests one scenario — can't compare 50+ what-if alternatives |
Bottleneck Identification
The Obvious Bottleneck
The station with the highest utilization (closest to 100%) is the active bottleneck — it sets the pace for the entire line. In the hero example: WS-03 at 97% utilization is the constraint. Every other station waits for WS-03. Adding capacity to WS-01, WS-04, or WS-06 achieves nothing — the line can't produce faster than WS-03 allows. Simulation identifies the active bottleneck instantly from utilization data.
The Moving Bottleneck
In high-mix production, the bottleneck shifts with product type. Product A bottlenecks at the CNC cell (long machining cycle). Product B bottlenecks at assembly (many components). Product C bottlenecks at quality inspection (complex measurements). A spreadsheet identifies zero bottlenecks because it averages across all products. Simulation runs each product mix scenario and shows where the bottleneck lands for each — and which layout handles all scenarios.
The Starvation Bottleneck
Sometimes the bottleneck isn't a machine — it's material supply. A workstation runs at 60% utilization but is idle 30% of the time waiting for parts from upstream. The station itself isn't slow; the feeding process can't keep up. This hidden bottleneck only appears when you simulate the complete system — machine capacity, buffer levels, and material handling together. Fixing the feeding process (adding a buffer, speeding the conveyor, or adding a parallel path) unlocks capacity the machine already has.
The Cascade Bottleneck
A machine breakdown at one station cascades upstream (blocking) and downstream (starvation) — creating temporary bottlenecks at stations that normally have spare capacity. A 30-minute breakdown at WS-03 can reduce line output by 2 hours if buffers are undersized. Simulation models these cascade effects and sizes buffers to absorb typical breakdown durations — so a single station failure doesn't collapse the entire line.
Buffer & WIP Optimization
Too Small: Starvation & Blocking
Buffers smaller than the cycle time difference between adjacent stations cause the faster station to block (can't discharge because the buffer is full) and the slower station to starve (empty buffer). A buffer of 0 between stations with 45s and 60s cycle times causes the 45s station to block 25% of the time — reducing its effective capacity to match the slower station. Simulation finds the minimum buffer size that limits blocking/starvation to <2% of productive time.
Too Large: Wasted Space & WIP Cost
Oversized buffers consume floor space ($50-$200 per square foot in US factory construction) and increase WIP inventory carrying cost (typically 20-30% of product value per year). A buffer holding 100 units of $500 product ties up $50,000 in WIP — plus the floor space, conveyors, and fixtures to hold them. Simulation finds the optimal buffer: large enough to absorb variability, small enough to minimize floor space and WIP cost.
Before Quality Gates
Quality inspection stations often have longer cycle times than production stations (detailed measurement takes time). Without adequate buffer before inspection, the production line blocks while waiting for inspection to complete. Simulation models the inspection station's throughput — including reject handling, rework routing, and re-inspection — to size the pre-inspection buffer that prevents production blocking while minimizing quality queue time.
Breakdown Absorption
The buffer after a breakdown-prone machine must hold enough WIP to feed downstream stations during the expected repair time (MTTR). If MTTR is 30 minutes and downstream demand is 2 parts per minute, the post-breakdown buffer needs at least 60 parts capacity. Simulation calculates this from MTBF/MTTR distributions — not from a single worst-case assumption that oversizes every buffer.
Need buffer sizes optimized for your specific production line? Schedule a demo to see how simulation finds the exact buffer capacity that balances throughput protection against WIP cost and floor space — for every station pair in your layout.
Operator Allocation & Shift Modeling
Skill-Based Assignment
Not all operators can run all machines. Simulation models operator skills: Operator A is certified for CNC and assembly; Operator B for welding and inspection only. When a breakdown occurs at the CNC cell, Operator A can cross-train to cover — but only if the simulation shows they're not already allocated to assembly at that time. The result: staffing plans that account for real cross-training capabilities, not theoretical "everyone can do everything."
Multi-Machine Tending
In US CNC shops, operators commonly tend 2-4 machines simultaneously — loading one while another cycles. Simulation models the walk time between machines, the load/unload time, and the machine cycle time to determine the maximum number of machines one operator can tend without creating idle machine time. Result: operator-to-machine ratio optimized to the second — often finding that 3 machines per operator is optimal where 4 causes 15% machine idle time.
Break & Fatigue Patterns
US manufacturing typically runs two 10-minute breaks and one 30-minute lunch per 8-hour shift. During breaks, lines without automatic buffers stop completely. Simulation models break staggering (half the operators break at :00, half at :15) and calculates the throughput recovery from staggered vs simultaneous breaks. Fatigue modeling: operator cycle times increasing 5-10% in the last 2 hours of a shift — affecting real throughput differently than hour 1.
Shift Pattern Scenarios
1 shift vs 2 shifts vs 3 shifts. 4×10 schedule vs 5×8. Weekend overtime. Each pattern produces different throughput because equipment warm-up, shift changeover, and maintenance windows vary. Simulation compares every shift pattern against production targets — answering "Can we meet demand on 2 shifts with overtime, or do we need a permanent third shift?" with data instead of guesswork.
Key Benefits & ROI
Your Spreadsheet Says 100 Parts/Hour. Simulation Says 72. Which Do You Trust?
iFactory models every workstation, buffer, conveyor, operator, and material handling path in your greenfield layout — then runs thousands of simulated production hours with realistic variability to validate throughput before you commit to construction.
Frequently Asked Questions
A $50K Simulation Prevents a $5M Layout Mistake
Every bottleneck found in simulation is a bottleneck you never experience in production. Every buffer sized correctly is floor space you don't waste. Every operator allocation validated is a shift plan that works from day one.
