Lecture by Haroon khan

Process Anti-Patterns – Common Mistakes in BPMN Modeling

Learning Objectives

After studying this lecture, you will be able to:

1. Identify six common BPMN modeling anti-patterns.

2. Correct a flawed BPMN diagram by applying standard modeling rules.

3. Explain why each anti-pattern leads to process execution or analysis problems.

4. What is a Process Anti-Pattern?

An anti-pattern is a common but ineffective or counterproductive solution to a recurring

problem. In BPMN modeling, anti-patterns produce diagrams that are ambiguous,
unexecutable, or hard to maintain. Recognizing them helps you write clean, correct process
models.

2. Six Classic BPMN Anti-Patterns

1. The Spaghetti Process

• Description: Many overlapping sequence flows, cross-connecting lines, and uncontrolled

conditional branches. The diagram looks like a plate of spaghetti.

• Problem: Impossible to follow, simulate, or implement. No clear start-to-end path.

• Typical cause: Adding exception paths without proper structure (sub-processes or event
handlers).

• Correction: Use sub-processes for exception handling. Keep the main flow linear. Use
AND/XOR gateways only where necessary.

2. The Swiss Cheese Process

• Description: Missing activities, hidden decisions, or implicit loops. The diagram has
“holes” where the reader must guess what happens.

• Problem: Different stakeholders interpretthe missing steps differently. Cannot be

executed by a workflow engine.

• Typical cause: Modeler assumes common knowledge (e.g., “of course we check
inventory before shipping” but no activity shown).

• Correction: Add every activity that affects the output or takes time. Show all decision
gateways explicitly.
3. The Deadly Embrace (Circular Dependency)
• Description: Two or more processes wait for each other in a cycle. For example: Process
A waits for B to complete; B waits for A to complete.

• Problem: In workflow execution, tokens are stuck forever (deadlock).

• Example: “Update customer address” process sends a message to “Invoice correction”
process and waits for reply; meanwhile “Invoice correction” waits for address update
before proceeding.

• Correction: Redesign to remove the cycle. Typically one process becomes a service
invoked synchronously, or you introduce a shared data store instead of mutual waiting.

4. The Overloaded Task

• Description: One activity that actually performs many distinct sub-steps (e.g., “Process
order” includes inventory check, payment, shipping, notification).

• Problem: Hides internal complexity. Cannot measure individual step times. Cannot
assign different resources to sub-steps.

• Correction: Expand the god task into a sub-process (collapsed or expanded) or break it
into separate tasks in the main diagram.

5. Orphan Tasks
• Description: An activity with no incoming sequence flow (cannot be reached) or no
outgoing sequence flow (cannot continue).

• Problem: Dead code – will never be executed or will cause the process to hang.
• Correction: Connect every task to a start event (or previous task) and to an end event (or
next task).

6. Mismatched Gateways (Split/Merge Mismatch)

• Description: A split gateway (e.g., XOR) is followed by a merge gateway of a different

type (e.g., AND). The number of incoming/outgoingtokens does not match.

• Example: XOR split (only one outgoing path taken) later meets an AND join (expects
tokens from all incoming paths). The AND join will wait forever for tokens that never
arrive.

• Correction: A split and its corresponding merge should use the same gateway type (XOR
with XOR, AND with AND, OR with OR).
3. How to Avoid Anti-Patterns (Best Practices)

• Keep it flat: No more than 15–20 tasks per diagram. Use sub-processes for details.

• Validate gateways: Every split has a matching merge of the same type.

• Start and end: One start event, one or more end events. Every path leads to an end.

• Use consistent naming: Verb-noun for tasks (e.g., “Verify credit card”).

• Walk the process: Mentally execute tokens through the diagram. Do any get stuck?

4. Example Correction

Flawed BPMN :
Start → (XOR split: if approved go to Task A; if rejected go to End) → Task A → (AND join with
incoming from Task B? But Task B never started) → End.

Problem: XOR split followed by AND join. The AND join expects a token from Task B that never
appears.

Correction: Change AND join to XOR join (simple merge). Now the token from Task A flows
directly to End.

Summary

• Anti-patterns are common modeling errors that cause confusion, deadlock, or

unexecutable diagrams.

• Six major patterns: Spaghetti, Swiss cheese, Deadly embrace, God task, Orphan tasks,
Mismatched gateways.

• Always validate split/merge pairs and ensure every task is reachable.

Process Mining on Your Own Browsing History

Learning Objectives

1. Explain the structure of an event log (case ID, activity, timestamp).

2. Use a simple process discovery algorithm to extract a process model from a log.

3. Interpret the discovered model and identify frequent paths and deviations.
1. What is an Event Log?
An event log is a collection of recorded events, each associated with a specific process instance
(case), an activity name, and a timestamp. Additional data (resource, cost, etc.) can be included.

Case ID Activity Timestamp

Session_001 Search product 2025-03-10 10:01:00

Session_001 View details 2025-03-10 10:03:00

Session_001 Add to cart 2025-03-10 10:05:00

Session_001 Remove from cart 2025-03-10 10:07:00

Session_001 Search product 2025-03-10 10:10:00

This log captures a user’s shopping behavior in one session (case). Process mining can discover
the typical order of activities.

2. Discovery – Extracting a Model from a Log

Discovery algorithms (e.g., Alpha miner, Heuristics miner, Inductive miner) read the log and
produce a BPMN-like model.

Simple “directly-follows” approach (conceptual):

• For each case, record which activity follows which.

• Build a directed graph: node = activity, edge = “A is directly followed by B in at least one
case”.

• Add frequencies.

Example from the shopping log:

• “Search product” → “View details” (1 case)

• “View details” → “Add to cart” (1 case)

• “Add to cart” → “Remove from cart” (1 case)

• “Remove from cart” → “Search product” (1 case – a loop!)

Discovered model: A cycle exists (Search → View → Add → Remove → Search). No clear end
event because the log cut off. In reality, many logs would have “Checkout” or “Exit”.

3. Process Mining on University Data (Safe Example)

Instead of real browsing history, use an anonymized log of course registration:

Case ID (Student) Activity Timestamp

S01 Login 09:00

S01 Search courses 09:02

S01 Enroll in CS101 09:05

S01 Enroll in MATH200 09:06

S01 Logout 09:10

S02 Login 10:00

S02 Enroll in CS101 10:01

S02 Logout 10:02

S03 Login 11:00

S03 Search courses 11:05

S03 Enroll in CS101 11:06

S03 Remove from CS101 11:10

Case ID (Student) Activity Timestamp

S03 Enroll in MATH200 11:12

S03 Logout 11:15

What the discovery shows:

• 67% of students directly enroll without searching.

• 33% search before enrolling.

• 11% (one student) enrolls, removes, then enrolls in another course – a loop (“change of
mind”).

• Every case ends with Logout.

The discovered model would have a XOR gateway: “Search?” Yes → Search → Enroll; No →
Enroll directly. Then an optional “Remove and re-enroll” loop.

4. Conformance Checking

You can also compare the discovered model to an “official” process model. For example, the
official registration process might require “Search courses” before enrollment. Conformance
checking would flag S02 and S03 as deviant (S02 never searched; S03 removed without
permission). Fitness score = (cases that follow the model) / total cases.

5. Tools for Practice (Free)

• PM4Py: Python library for process mining.

• Disco (Fluxicon): Free limited version, very user-friendly.

• Apromore CE: Community edition with discovery and conformance.

Summary

• Event logs are the raw material of process mining.

• Discovery creates a model showing actual behavior (not the prescribed one).

• Conformance checking measures how well reality matches the intended model.

• Even simple logs (e.g., university registration, library borrowing) reveal interesting
patterns.
Process Costing – How Much Does One Process Instance
Really Cost?
Learning Objectives

1. Define activity-based costing (ABC) for business processes.

2. Calculate total cost per process instance by summing activity costs.

3. Use process costing to evaluate automation decisions.

4. Why Cost a Process?

Process improvement is often driven by cost reduction. But to reduce cost, you must first
measure it. Process costing assigns monetary values to each activity, waiting period, and defect.

2. Activity-Based Costing (ABC)

ABC assigns costs to activities based on their consumption of resources (labor, materials,
systems, overhead).

Steps:

1. Identify all activities in the process (from BPMN).

2. For each activity, determine:

o Labor cost: time × hourly wage (including benefits)

o System cost: per-use cost of software/hardware (e.g., $0.10 per database query)

o Material cost: paper, postage, consumables

o Overhead: allocated share of rent, utilities, management (often a fixed % of

labor)

3. Sum for total activity cost.

4. Multiply by the number of times the activity is performed per case (usually once, but
loops increase count).
3. Example: Invoice Approval Process

Total cost
Hourly Labor System
Activity Duration Resource per
wage cost cost
activity

Receive
invoice $0.10
5 min Clerk $20 $1.67 $1.77
(manual (ERP)
entry)

Verify against
4 min Clerk $20 $1.33 $0.10 $1.43
PO

Manager
2 min Manager $50 $1.67 $0.05 $1.72
approval

Payment $0.20
3 min Clerk $20 $1.00 (bank $1.20
execution
fee)

Total cost per invoice = $1.77 + $1.43 + $1.72 + $1.20 = $6.12

4. Including Waiting and Errors

• Waiting time (invoice sits in manager’s inbox for 2 days) has no direct labor cost, but it
may incur opportunity cost (late payment penalty) or customer
dissatisfaction (estimated $0.50 per day).

• Defects (invoice rejected, rework) double the cost for that case. A 10% rejection rate
adds 0.1 × cost to the average.

Example with defects:

If 10% of invoices are rejected and require a full re-run (another $6.12), the average cost
becomes:
$6.12 + (0.10 × $6.12) = $6.73 per invoice.

5. Using Costing for Automation Decisions

Compare current cost to automated cost.

Manual process cost per case = $6.12
Automated process (using OCR + workflow engine):

• One-time development cost: $50,000

• Annual maintenance: $5,000

• Operational cost per case (cloud API calls, electricity) = $0.50

Break-even calculation:
Annual volume = V.
Manual annual cost = V × $6.12
Automated annual cost = $5,000 + V × $0.50
Solve V × 6.12 = 5,000 + V × 0.50 → V × 5.62 = 5,000 → V ≈ 890 cases per year.
If your company processes more than 890 invoices/year, automation is cheaper after the first
year.

6. Simple Process Costing Template (Mental Model)

• Cost per case = Σ (activity cost) + (defect rate × Σ activity cost) + (waiting penalty)
• Automation investment justified if (current cost − automated cost) × volume >
development cost

Summary

• Activity-based costing assigns real money to process steps.

• Waiting and defects add hidden costs.

• Cost comparisons guide build-vs-automate decisions.

Process Design Thinking – A Workshop in 50 Minutes

Learning Objectives

1. Apply the five stages of design thinking to a business process.

2. Create a customer journey map as a precursor to BPMN.

3. Rapidly prototype a process using sticky notes or a whiteboard.

1. What is Design Thinking?
Design thinking is a human-centered, iterative approach to solving problems. For BPE, it helps
you design processes that customers (internal or external) actually want to use.

Five stages :

• Empathize – Understand the user’s needs, pains, and context.

• Define – Frame the problem as a specific design challenge.

• Ideate – Generate many possible process flows (no judgment yet).

• Prototype – Draw a simple BPMN diagram (low-fidelity).

• Test – Walk through the prototype with a role-play or simulation.

2. Workshop Example: Food Delivery Complaint Handling

Stage 1: Empathize

• Who is the user? A customer whose order is wrong (missing items, incorrect food).

• What do they feel? Frustrated, hungry, powerless.

• What do they need? Quick resolution, apology, replacement or refund, easy

communication.

Stage 2: Define

• Problem statement: “Customers who receive wrong orders currently wait >20 minutes
on hold and often give up. We need a process that resolves complaints in under 5
minutes with minimal effort.”

Stage 3: Ideate (Brainstorm activities)

• Customer opens app → “Report issue” button.

• AI chatbot asks what’s wrong (photo upload?).

• Options: Replace order, refund, credit for next order.

• Assign to human only if AI fails.

• Notify driver/restaurant only for replacement.

• Send confirmation and apology coupon.

Stage 4: Prototype (Simple BPMN)
Start (Customer clicks “Report issue”) → (XOR)

• Path 1: AI chatbot resolves → End (refund/credit)

• Path 2: AI escalates → Human agent → Resolution → End

Attach loop: If customer not satisfied → back to human.

Stage 5: Test

• One student plays customer, another plays AI (read script), third plays human agent.
Walk through the flow. Time each step. Adjust if too long.

3. From Journey Map to BPMN

Before drawing BPMN, create an emotional journey map (see next lecture). Then annotate
each emotional dip with a process activity that addresses it.

4. Workshop Materials (What You Need)

• Sticky notes (different colors for activities, decisions, events)

• Whiteboard or large paper

• Timer (5 minutes per stage)

• A real problem to solve (e.g., “university library book return process”)

Summary

• Design thinking brings user empathy into process design.

• The five stages guide rapid, creative problem solving.

• Low-fidelity BPMN prototypes are enough to test early ideas.

Process Versioning and Migration

Learning Objectives

1. Explain why business processes need versioning.

2. Describe three migration strategies for changing a live process.

3. Understand how workflow engines support versioning.

1. Why Version Processes?

Like software, business processes evolve:

• New regulations (GDPR, tax laws)

• Improved automation (RPA, AI)

• Organizational restructuring

• Bug fixes (e.g., missing approval step)

Without versioning, you cannot safely update a running process. Long-running cases (e.g.,
insurance claims that take months) must finish on the old version while new cases use the new
version.

1. Process Metadata for Versioning

Each process model should store:

• Version ID (e.g., v1.0, v1.1, v2.0)

• Effective date (when this version becomes active)

• Deprecation date (when support ends)

• Author and change log

1. Migration Strategies(Three Main Approaches)

1. Cold Turkey (Abrupt Switch)

• How: Stop accepting new cases on old version. All new cases use new version. Old
running cases continue on old version until completion.

• Pros: Simple, no mixed-version complexity.

• Cons: Old version must remain available for months; two codebases to maintain.

2. Parallel Runs

• How: Every new case is processed simultaneously by both old and new versions.
Compare outcomes (time, cost, errors). After validation (e.g., 100 cases), switch fully to
new version.

• Pros: Safe; detect problems before full deployment.

• Cons: Doubles resource consumption during parallel run.

3.3 Phased Roll-out (Canary)
• How: Route a small percentage (e.g., 5% of new cases) to the new version; rest to old
version. Gradually increase percentage if no issues.

• Pros: Low risk; can roll back instantly.

• Cons: Requires routing logic in the workflow engine (A/B testing).

4. Workflow Engine Support for Versioning

Modern BPM engines (Camunda, jBPM, Activiti) handle versioning automatically:

• Each process definition is stored with a version number

(e.g., orderProcess:1, orderProcess:2).

• When starting a new case, the engine uses the latest active version unless overridden.
• Running cases are pinned to the version they started with. They load the old BPMN file
when they resume.

Example:

• March 1: Process v1 deployed. Case #100 starts.

• March 15: Process v2 deployed. Case #101 starts → uses v2.

• March 20: Case #100 resumes → still uses v1 (its BPMN snapshot).

5. Migration of Running Cases (Optional)

Sometimes you must migrate old cases to the new version (e.g., legal requirement). This is
complex because the token state may not match the new diagram. Strategies:

• Abort and restart: Rarely acceptable.

• State transformation: Write a script that maps old token positions to new positions.

• Hybrid: Keep old version but redirect future steps to new sub-process via an adapter.

Summary

• Versioning allows safe evolution of processes while long-running cases finish.

• Three migration strategies: cold turkey, parallel runs, phased roll-out.

• Workflow engines provide built-in version support by pinning cases to their start version.
Emotional Journey Mapping – Complement to BPMN
Learning Objectives

1. Create an emotional journey map from a BPMN process.

2. Identify points of frustration and delight.

3. Redesign a process to improve the emotional curve.

4. What is an Emotional Journey Map?

While BPMN captures activities and flows, an emotional journey map captures how the user
feels at each step. It plots time (or process steps) on the x-axis and emotional state (negative to
positive) on the y-axis.

Common emotions:
Frustrated, anxious, confused, bored (negative) → neutral → content, delighted, relieved
(positive).

2. Why BPMN Alone is Not Enough

A process can be efficient (short cycle time) but still make customers angry. Example: A fully
automated phone tree with no human agent. Low cost, fast routing, but emotional score = very
low.

Improving process without considering emotion can destroy customer loyalty. Emotional
journey mapping brings empathy into BPE.
3. How to Build an Emotional Journey Map

Step 1: List the process steps (from BPMN).

Example: Online return request

1. Customer logs into account

2. Navigates to “My Orders”

3. Clicks “Return Item”

4. Fills out reason form

5. Prints return label

6. Drops package at post office

7. Waits for refund (3–5 days)

Step 2: Assign emotional score per step (-3 to +3).

• Step 1 (login): Neutral (0)

• Step 2 (navigate): Frustrating if many clicks (-1)

• Step 3 (click return): Relief found (+1)

• Step 4 (fill form): Annoying (-1)

• Step 5 (print label): Neutral (0)

• Step 6 (drop off): Hassle (-2)

• Step 7 (wait for refund): Anxious (-2)

Step 3: Plot the curve. Connect the scores. You see dips at form filling, dropping off, and
waiting.

Step 4: Redesign to raise the curve.

• Eliminate step 4: use AI to auto-fill reason from order history.

• Step 6: offer free pickup by courier (turn hassle into delight +2).

• Step 7: issue instant store credit instead of waiting.

New emotional curve: overall higher, with peaks at the “instant credit” moment.
4. Example: Call Center Support

Step Emotion Score

Dial number Anticipation 0

IVR menu (“press 1 for…”) Confusion -2

Hold music (5 min) Frustration -3

Agent answers Relief +2

Agent solves problem Delight +3

Step Emotion Score

Survey request Annoyance -1

Redesign:

• Replace IVR with “say your issue” (AI) → reduces confusion to -1.

• Offer callback instead of hold → removes -3 frustration.

• Send SMS with resolution summary instead of survey → removes -1 annoyance.

New emotional curve never goes below -1, and peaks at +3.

5. Combining with BPMN

Annotate BPMN activities with expected emotional score (e.g., a small heart icon with color).
Use this to guide improvement: focus on steps with most negative emotion, even if they are
cheap and fast.

Summary

• Emotional journey mapping reveals hidden customer pain.

• Plot emotion vs. process steps, then redesign to raise the curve.

• Efficient + delightful is the ultimate goal.

Process Time Travel – Analyzing Historical Process Changes

Learning Objectives

1. Trace the evolution of a real-world process over decades.

2. Identify which BPE principles (specialization, parallelism, postponement) were applied at
each stage.

3. Learn lessons from historical redesigns.

1. Why Study Process History?

Understanding how processes evolved teaches you to anticipate future changes. Many “new”
ideas (e.g., postponement, pull systems) were invented decades ago and remain relevant.
2. Case Study: McDonald’s Burger Making Process

1940s – Cook to Order (Craft Process)

• One cook handled entire burger: take order → cook patty → toast bun → assemble →
serve.

• Cycle time: 10–15 minutes per burger.

• Problem: Long wait during rushes. Inconsistent quality.

1960s – The Speedee System (Assembly Line)

• Inspired by Ford’s car assembly.

• Workers specialized: one person toasts buns, one cooks patties, one adds condiments,
one wraps.

• Parallelism: Multiple burgers in different stages simultaneously.

• Cycle time: Reduced to 30 seconds per burger.

• BPE principle applied: Division of labor, parallel activities.

1990s – Made-to-Order (Postponement)

• Customer demands customization (no pickles, extra cheese).

• Old assembly line could not handle variation.

• Redesign: Pre-cook patties, keep warm; final assembly only after order is taken.

• Postponement principle: Delay differentiation until customer knows what they want.

• Trade-off: Slight increase in cycle time (1 minute) but much higher customer satisfaction.

2010s – Digital Kiosks & Kitchen Display Systems

• Customer orders via touchscreen→ order sent directly to kitchen display.

• Kitchen workers see all orders at once; they can batch similar items.

• BPE principle: Information integration, elimination of cashier handoff.

• Result: Fewer errors, upselling, data collection.

3. Lessons Learned

• Specialization reduces cycle time but may reduce flexibility.

• Postponement handles variety without sacrificing speed.

 • Information technology (kiosks, displays) enables new process architectures that were
impossible with paper.

4. Another Example: Airport Security Screening

Era Process Bottleneck Redesign

Simple metal detector, no

Pre-9/11 None (fast) Security low
shoe removal

2002– Remove shoes, laptops out, Shoe

liquids in bag Added more lanes
2010 removal

2010– TSA PreCheck (trusted Regular Segmentation

2020 travelerskeep shoes on) lane (parallel processes)

CT scanners (laptops/liquids Scanning Technology

2020+
stay inside bags) time substitution

Principle: Segmentation (separate fast lane for low-risk passengers) is a form of XOR gateway
based on traveler profile.

5. How to Use History in Your Own Work

When redesigning a process, ask:

• Has this been solved before in another industry?

• What would Henry Ford (assembly line) or Taiichi Ohno (Lean) do?

• Can we apply postponement? Parallelism? Segmentation?

Summary

• Studying process history is like studying design patterns for business processes.

• McDonald’s and airport security show how specialization, postponement, segmentation,

and IT transform processes.

• History prevents reinventing the wheel.

Process Olympics – Comparing Two Processes for the Same
Goal
Learning Objectives

1. Benchmark two different processes against the same performance metrics.

2. Identify best practices from one process that can be applied to the other.

3. Present findings as a structured comparison.

4. What is the Process Olympics?

It is a team exercise (or mental framework) where you select two processes that aim to achieve
the same outcome (e.g., “getting a passport” vs. “getting a driver’s license”; “returning a
product to Amazon” vs. “returning to a local store”). You then compare them across a set of
metrics to determine which is “better” and why.

2. Comparison Metrics (The Scorecard)

Metric What it measures

Cycle time Total elapsed time from start to end

Number of handoffs How many times the case moves between different people/teams

Number of decisions (gateways) Complexity of the flow

Customer steps How many actions the customer must perform

Error rate Percentage of cases that need rework

Cost Estimated total cost (if data available)

Emotional score From journey mapping (optional)

3. Example Comparison: Passport Application vs. Driver’s License

Passport Process (Country A)

• Steps: Fill online form → Upload photo → Pay fee → Mail documents → Wait 6 weeks →
Receive passport.

• Handoffs: 3 (online system → postal service → passport office).

• Customer steps: 4.

• Emotional: Bored waiting.

Driver’s License Process (Same Country)

• Steps: Visit DMV → Take number → Wait → Submit form → Take photo → Take eye test
→ Pay → Get temporary license → Wait 2 weeks for card.

• Handoffs: 5 (front desk → tester → cashier → printer → mail).

• Customer steps: 8 (including waiting).

• Emotional: Frustrating (long wait, many queues).

Winner (by cycle time & customer steps): Passport process is more efficient, despite longer
total calendar time (6 weeks vs. 2 weeks) because customer active time is much lower.

4. Transferable Best Practices

• From passport to license: Allow online form submission before visiting. Reduce
in-person steps.

• From license to passport: Add an express option (pay more, get faster) as DMV does for
same-day licenses.

• Both could improve: Send SMS updates (license does not; passport does via email).

5. How to Run a Process Olympics (Team Activity)

1. Select two processes (instructor provides or teams choose).

2. Map each process as a high-level BPMN diagram (5–10 tasks).

3. Collect data (estimate if real data unavailable – state assumptions).

4. Fill the scorecard.

5. Declare a winner in each category (may be different winners for different metrics).
 6. Recommend improvements for the loser based on the winner’s design.

6. Examples

• Returning an online purchase vs. returning an in-store purchase.

• Booking a flight via website vs. via travel agent.

• Reporting a bug in open-source software vs. in commercial software.

• Getting a medical prescription refill online vs. visiting a clinic.

Summary

• Process Olympics is a structured way to learn from comparison.

• Use a standard scorecard: cycle time, handoffs, customer steps, errors, cost, emotion.

• Always ask: “What can the worse process learn from the better one?”