Lesson Overview
A business can have a great product and still disappoint customers if the process behind it is slow, confusing, or overloaded. Process design is the discipline of organizing work so that value flows smoothly—from request to delivery.
In this lesson, you’ll learn how to map a process, measure capacity, identify constraints, and understand why bottlenecks create lines, delays, and missed deadlines. The goal is simple: design systems that deliver faster and more reliably without wasting resources.
Learning Objectives
- Define process flow and explain why flow is the core of operational performance.
- Map a process using basic steps, roles, and handoffs.
- Calculate step capacity and identify the bottleneck (constraint).
- Explain how bottlenecks determine throughput and create queues/wait times.
- Apply practical strategies to improve flow (reduce work, rebalance, add capacity, simplify variation).
What Is a Process?
A process is a repeatable sequence of steps that transforms inputs into outputs. Examples include fulfilling an online order, onboarding a new employee, approving a loan, or preparing a meal.
Every process has:
- Steps (what happens)
- Resources (who/what does it)
- Time (how long each step takes)
- Flow units (what moves through the process: customers, orders, calls, claims, parts)
Flow: The Real Product of Operations
In operations, performance is often less about any single step and more about the flow of work through the whole system. When flow is smooth, customers experience speed and reliability. When flow is choppy, customers experience delays, errors, and frustration.
Flow breaks down most often at:
- Handoffs (work passes between people or teams)
- Queues (work piles up waiting for a resource)
- Rework loops (errors send work backward)
- Unbalanced steps (one step is much slower than others)
Key Measures: Capacity, Throughput, Cycle Time, and WIP
Process design uses a small set of measures that work in almost any industry:
- Capacity: maximum output rate (units per time)
- Throughput: actual output rate achieved
- Cycle time: time it takes one unit to go from start to finish
- Work-in-process (WIP): how many units are “in the system” at once (in work or waiting)
A simple but powerful relationship: when WIP rises while throughput stays the same, cycle time (wait time) usually rises. That’s why crowded systems feel slow.
Understanding Bottlenecks (Constraints)
A bottleneck is the step with the lowest effective capacity relative to demand. It is the system’s limiting factor—the reason you can’t go faster even if other steps have spare time.
In most real processes, one constraint sets the pace for the entire system:
- If the kitchen is slow, the dining room can’t serve faster.
- If final inspection is slow, production can’t ship faster.
- If approvals are slow, sales can’t close faster.
Rule of thumb: improving non-bottleneck steps rarely increases overall throughput. It may make people feel busy, but it does not increase what the system delivers.
How to Find the Bottleneck
You can find bottlenecks in two practical ways:
1) Measure step times and compute capacity
If a step takes 2 minutes per unit, one worker has a capacity of about 30 units/hour (60 ÷ 2). Compare each step’s capacity to demand.
2) Look for where work piles up
The bottleneck is usually where you see the largest queue, the most waiting, and the most “work stuck in limbo.” Piles of unfinished work are a sign the system is constrained there.
Mini Case: A Simple Process Calculation
Imagine a small bakery with three steps for custom cupcake orders:
- Order & payment: 1 minute per order (capacity ≈ 60 orders/hour)
- Decorate cupcakes: 3 minutes per order (capacity ≈ 20 orders/hour)
- Pack & handoff: 1.5 minutes per order (capacity ≈ 40 orders/hour)
The decorating step is the bottleneck at about 20 orders/hour. Even if the cashier and packer are fast, total throughput cannot exceed decorating capacity unless the system changes.
Why Bottlenecks Create Wait Times
When demand approaches a bottleneck’s capacity, small variations cause big delays:
- One complicated order takes longer than average.
- A worker steps away for a minute.
- A machine needs resetting.
If the system is already running near full utilization, there is no “slack” to absorb these variations—so a queue forms. Once a queue forms, cycle time rises because each new unit must wait its turn.
Design Choices That Shape Process Performance
Process structure: line vs. flexible stations
- Assembly line: fast and consistent for high volume, low variety.
- Flexible stations: better for customization, but harder to schedule and balance.
Push vs. pull systems
- Push: work is released based on forecasts (can create excess WIP and clutter).
- Pull: work is released based on actual demand or downstream readiness (reduces WIP and improves flow).
Batching
Processing items in batches can reduce setup time (efficient) but increases waiting for the batch to fill (slower for customers). Many processes improve dramatically by reducing batch sizes.
How to Improve a Bottleneck (Practical Strategies)
Once you know the constraint, you have several options:
- Reduce work at the bottleneck: simplify, remove steps, standardize inputs.
- Increase capacity: add staff, extend hours, improve tools, reduce downtime.
- Rebalance work: move tasks from the bottleneck to non-bottleneck steps.
- Improve quality upstream: prevent defects that create rework at the constraint.
- Manage demand: appointments, pricing, prioritization, or smoothing arrivals.
The best improvements usually combine two ideas: make the constraint faster and make the constraint do less.
Practice: Check Your Understanding
- Think of a process you’ve experienced recently (coffee line, shipping return, doctor visit). Where was the queue?
- Why does improving a non-bottleneck step often fail to improve overall throughput?
- A step takes 4 minutes per unit. What is its approximate capacity per hour?
- Name one strategy to improve a bottleneck without hiring more people.
What’s Next?
In Lesson 4.3: Quality Control & Continuous Improvement, we’ll focus on standards, measurement, root-cause analysis, and how improving quality reduces rework and increases system performance over time.