AI Workflow Foundations: Process mapping and bottleneck discovery

Process Mapping & Bottleneck Discovery

What This Is

Process mapping is a visual method to document how work actually flows through a system—step by step, including handoffs, delays, and decision points. It matters because most inefficiencies hide in the gaps between steps, not within them. For example, a hospital reduced patient wait times by 30% after mapping its discharge process and discovering that paperwork approvals (not staffing) were the real bottleneck.

Key Facts & Principles

• Process map (vs. org chart): A diagram showing how work gets done, not who reports to whom. Example: A flowchart of how a customer complaint moves from intake-triage-resolution (not just the team hierarchy).
• Bottleneck: The step that limits the entire system’s output. Always the slowest or most constrained resource. Example: A factory’s assembly line is only as fast as its slowest machine.
• Value-add vs. non-value-add: Value-add steps directly contribute to the customer’s goal (e.g., assembling a product). Non-value-add steps (e.g., approvals, rework) should be minimized or eliminated.
• Cycle time vs. lead time: Cycle time = time to complete one unit of work (e.g., 2 hours to process an invoice). Lead time = total time from request to delivery (e.g., 5 days due to approvals and queues).
• Little’s Law: Throughput = Work in Progress (WIP) / Cycle Time. If your team has 20 open tickets and closes 5 per week, average cycle time is 4 weeks. Reduce WIP or cycle time to increase throughput.
• Theory of Constraints (TOC): Focus improvement efforts on the single bottleneck—fixing anything else won’t improve overall output. Example: If a call center’s bottleneck is agent training, hiring more reps won’t help.
• Swimlane diagram: A process map that separates steps by role/department to highlight handoffs and delays. Example: Mapping how a loan application moves between sales, underwriting, and compliance.
• Gemba walk: Observing the process where it happens (not in a meeting room) to spot inefficiencies. Example: Watching nurses document patient notes to see why it takes 20 minutes per chart.

Step-by-Step Application

1. Define scope and goal
2. Pick one process (e.g., "order fulfillment" or "employee onboarding").

3. Set a clear goal: "Reduce lead time by 20%" or "Cut rework by 50%."

4. Map the current process

5. Use sticky notes or tools like Lucidchart/Miro to document each step.
6. Include: Who does it? How long does it take? What tools are used? Where are the handoffs?

7. Pro tip: Ask frontline workers, not managers—they know the real pain points.

8. Identify bottlenecks

9. Look for: Long wait times, high rework rates, or steps where work piles up.
10. Use data: Cycle time metrics, queue lengths, or error logs.

11. Example: If 80% of orders sit in "approval" for 3 days, that’s your bottleneck.

12. Test fixes with small experiments

13. Apply TOC: Focus on the one biggest bottleneck.
14. Try quick wins: Automate a manual step, reduce approval layers, or cross-train staff.

15. Example: If approvals are slow, test a rule: "Auto-approve orders under $1,000."

16. Measure and iterate

17. Track cycle time, error rates, or throughput before/after changes.
18. If the bottleneck moves (e.g., approvals speed up but shipping slows), repeat the process.

Common Mistakes

• Mistake: Mapping the ideal process instead of the actual one. Correction: Observe real work (Gemba walk) and ask, "What really happens when X goes wrong?" Ideal maps hide bottlenecks.

• Mistake: Fixing symptoms, not root causes. Correction: Use the "5 Whys" technique. Example: "Why are orders delayed?"-"Approval takes 3 days."-"Why?"-"Manager is overloaded."-Fix the manager’s workload, not the approval step.

• Mistake: Ignoring handoffs between teams. Correction: Use swimlane diagrams to spot delays where work transfers (e.g., sales-operations). Handoffs are where 60% of bottlenecks hide.

• Mistake: Assuming automation will fix everything. Correction: Automate after simplifying the process. Example: Automating a 10-step approval process just makes bad workflows faster.

• Mistake: Not measuring before/after changes. Correction: Track cycle time, error rates, or cost per unit. If you can’t measure it, you can’t improve it.

Practical Tips

• Start small: Pick a process that’s painful but not mission-critical (e.g., expense reimbursements, not payroll).
• Use the "80/20 rule": 20% of steps cause 80% of delays. Focus there first.
• Involve the team: Frontline workers will resist changes if they’re not part of the solution.
• Watch for "shifting bottlenecks": Fixing one may reveal another. Example: Speeding up approvals might expose a slow shipping process.

Quick Practice Scenario

Scenario: Your team processes customer refunds. The process takes 10 days on average, but customers complain it’s too slow. You map the steps:
1. Customer submits request (5 min).
2. Support agent reviews (1 day).
3. Manager approves (3 days).
4. Finance processes (2 days).
5. Customer notified (1 day).

Question: Where is the bottleneck, and what’s one quick fix?

Answer: The manager approval (3 days) is the bottleneck. Quick fix: Auto-approve refunds under $100. Why: Reduces cycle time by 30% without major changes.

Last-Minute Cram Sheet

1. Process map = visual of how work flows, not org structure.
2. Bottleneck = slowest step; fix this first (Theory of Constraints).
3. Cycle time = time per unit; lead time = total time from request to delivery.
4. Little’s Law: Throughput = WIP / Cycle Time. Don’t confuse WIP with backlog.
5. Value-add = steps the customer cares about; cut the rest.
6. Swimlanes = show handoffs between teams (where most delays hide).
7. Gemba walk = observe the process where it happens. Don’t rely on reports.
8. 5 Whys = dig for root causes, not symptoms.
9. Automate last—simplify first. Automating a bad process makes it worse.
10. Measure before/after—if you can’t measure it, you can’t improve it.