Business Process Model and Notation (BPMN)

Introduction

Every organization runs on processes — some documented, most not, and almost none described the same way by two different people. A purchase request, a loan application, an employee onboarding, a monthly billing run: each is a sequence of decisions and handoffs that is easy to perform and surprisingly hard to describe precisely. This gap between doing a process and being able to communicate it is where most improvement, automation, and compliance efforts quietly stall.

BPMN — Business Process Model and Notation — exists to close that gap. Standardized by the OMG and now at version 2.0.2, it provides a single visual vocabulary that business stakeholders can read without training, analysts can use to diagnose and redesign, and developers can compile into executable process definitions. Its strength is not decorative boxes and arrows; it is a grammar. Events say what happened, activities say what was done and by whom, gateways say under what conditions, and pools and lanes say who owns the work and where responsibility changes hands. A BPMN diagram is therefore simultaneously a communication tool, an analysis artifact, and a specification.

Business Process Model and Notation (BPMN)

This article walks through that grammar from the ground up. It begins with the foundational concepts — pools, lanes, flows, tokens — then surveys the full element and notation set: the three flow-object families (events, activities, gateways), their triggers, markers, and subtypes, plus the data objects and artifacts that surround them. Three worked examples follow, each written in PlantUML and each targeting a different modeling concern: a two-pool purchasing process that exercises exclusive and inclusive gateways, an event-driven billing run built around boundary and intermediate events, and a single-pool onboarding process that demonstrates lane hierarchy and sub-process abstraction. The article closes with the modeling conventions that separate a diagram that merely renders from one that is actually correct — naming discipline, gateway pairing, pool boundaries, and the choice of abstraction level.

BPMN is an OMG standard (v2.0.2) for modeling business processes. Its selling point is that a single notation is readable by business analysts, process owners, and technical developers — and is precise enough to be executed by a BPM engine.


1. Key concepts

Concept Meaning
Pool An independent participant (organization, company, system). Represents a process boundary; flows cannot cross pools without messages.
Lane A subdivision within a pool — department, role, or system responsible for the tasks in it.
Flow object The three core element families: Events, Activities, Gateways.
Sequence flow Solid arrow. Order of execution inside one pool.
Message flow Dashed arrow. Communication between pools.
Association Dotted line. Links artifacts (data, annotations) to flow objects.
Token The conceptual “unit of execution” that travels through the process; gateways split/merge tokens.

2. Elements & notation

Events — circles

  • Start event — thin single circle. One per process (unless event sub-processes).

  • Intermediate event — double thin circle. On the normal path (catch) or on a boundary.

  • End event — thick single circle. Consumes the token.

  • Boundary event — double circle on the border of an activity. Non-interrupting = dashed border.

Event triggers are denoted by an inner icon:

Icon Meaning Catching / Throwing
None Plain start/end —
✉ Message Message received / sent catch / throw
⏱ Timer Date, duration, cycle catch only
⚠ Error Exception catch / throw
⟳ Escalation, ✋ Signal, ⚡ Conditional, ⬛ Terminate — — —

Activities — rounded rectangles

Type Notation Use
Task plain rounded rect atomic work
User Task small person icon human performed via UI
Service Task gear icon automated by system/ser​vice
Manual Task hand icon off-system human work
Script Task script icon executed by engine
Business Rule Task table icon rule engine invocation
Send / Receive Task envelope (filled / open) messaging
Sub-process rounded rect with [+] collapsed detail
Call Activity thick-bordered rounded rect reuses another process

Activity markers: [+] loop = standard, [↻] = multi-instance parallel, [|||] = multi-instance sequential, [~] = compensation.

Gateways — diamonds

Gateway Symbol Behavior
Exclusive (XOR) X or empty Exactly one outgoing branch. Merge = pass-through.
Inclusive (OR) O One or more branches whose condition holds.
Parallel (AND) + All branches always.
Event-Based pentagon + event Waits for the first of several events.
Complex * Custom logic (rarely used).

Data & artifacts

  • Data object — document icon. Data store — cylinder. Data input/output — arrow-tipped rectangles.

  • Text annotation — open bracket. Group — dashed rounded rect. These do not affect the token flow.

Connecting objects

sequence flow (solid, ⊕ arrowhead) · message flow (dashed, open arrowhead) · association (dotted, no arrowhead).


3. Example — Purchase Requisition Process

A process with two pools (Requester, Procurement) and gateways of three types, including an inclusive split/join and a boundary error.

@startuml
<style>
    element { MaximumWidth 160 }
</style>
title Purchase Requisition Business Process Diagram
|Requester:Employee|
start
:<<UserTask>>
Create Purchase Requisition;
:<<UserTask>>
Add Cost Center and Justification;
:<<SendTask>>
Submit Requisition to Procurement;
|#E8F4F8|Procurement:Buyer|
:<<ReceiveTask>>
Receive Requisition;
:<<BusinessRuleTask>>
Validate Budget Availability;

if (Budget Sufficient?) then (yes)
  :<<InclusiveGateway>>
Assess Sourcing Scope;
  fork
    :<<UserTask>>
Request Quotes from Vendors;
  fork again
    :<<ServiceTask>>
Check Preferred Supplier Catalog;
  fork again
    :<<ServiceTask>>
Verify Contract Coverage;
  end fork
  :<<InclusiveGateway>>
Consolidate Sourcing Results;
  if (Value Above Threshold?) then (yes)
    :<<UserTask>>
Obtain Management Approval;
    if (Approved?) then (yes)
      :<<ServiceTask>>
Issue Purchase Order;
    else (no)
      :<<ScriptTask>>
Record Rejection Reason;
      :<<SendTask>>
Notify Requester of Rejection;
      stop
    endif
  else (no)
    :<<ServiceTask>>
Issue Purchase Order;
  endif
  :<<SendTask>>
Send Purchase Order to Supplier;
else (no)
  :<<ManualTask>>
Escalate Budget Exception;
  :<<SendTask>>
Notify Requester of Budget Block;
  stop
endif
|Finance:Accounts Payable|
:<<ReceiveTask>>
Receive Invoiceless Order Confirmation;
:<<UserTask>>
Match Order, Receipt and Invoice;
:<<ServiceTask>>
Release Payment;
stop
@enduml


4. Example — Employee onboarding (single pool, hierarchy via lanes)

Demonstrates lane naming, sub-process abstraction, and a merge gateway.

@startuml
<style>
    element { MaximumWidth 160 }
</style>
title Employee Onboarding Business Process Diagram
|HR:Recruiting|
start
:<<ServiceTask>>
Create Candidate Record;
:<<UserTask>>
Issue Employment Offer;
if (Offer Accepted?) then (yes)
  :<<SendTask>>
Notify HR Operations;
else (no)
  :<<UserTask>>
Close Requisition;
  stop
endif
|HR:Operations|
:<<ReceiveTask>>
Receive Acceptance Notice;
:<<ServiceTask>>
Provision Payroll and Benefits;
:<<ServiceTask>>
Request IT Accounts;
|IT:Service Desk|
:<<ReceiveTask>>
Receive Account Request;
:<<ScriptTask>>
Create Directory Account;
:<<ManualTask>>
Issue Laptop and Access Badge;
:<<SendTask>>
Confirm Provisioning Complete;
|HR:Operations|
:<<ReceiveTask>>
Receive Provisioning Confirmation;
:<<UserTask>>
Schedule Orientation Session;
:<<SendTask>>
Send Day-One Instructions to Employee;
stop
@enduml



5. Practical modeling rules

Do

  • Name every task with verb + noun (“Validate Budget”), every gateway with a question (“Budget Sufficient?”), and every event with a state change (“Requisition Received”).

  • Keep one start event per pool and make the happy path traceable left-to-right.

  • Pair every split gateway with a matching join (except XOR merges, which need no logic).

  • Use pools only where a real organizational boundary exists; over-pooling fragments the story.

Avoid

  • Sequence flows crossing pool boundaries — that must be a message flow.

  • OR-joins without explicit conditions (they can deadlock); prefer XOR or AND where possible.

  • Modelling decisions as activities (“Decide whether…”) instead of gateways.

  • Mixing abstraction levels inside one pool (tasks next to sub-processes next to whole departments).

  • Text annotations carrying the real logic — if it matters to execution, it belongs in the model.

Abstraction choice — BPMN is often used at three levels: descriptive (few element types, for business alignment), analytical (full notation, for improvement analysis), executable (complete data and condition definitions, BPEL/DMN-ready). Decide which level you are drawing before you start.

Conclusion

BPMN rewards precision, and precision has a price: the notation offers well over a hundred symbols, which is exactly what makes it powerful and exactly why most BPMN diagrams in the wild are unreliable. The escape from that trap is not memorizing every icon — it is internalizing a small number of rules and applying them relentlessly.

First, semantics over decoration. A gateway exists to split or merge control flow, so a decision belongs in a gateway, never in a task named “Decide whether to approve.” A message between participants is a message flow, never a sequence flow crossing a pool boundary. A start event, an end event, and a balanced pair of splits and joins should all be present in anything you intend to execute or audit.

Second, abstraction must be declared, not implied. Descriptive models serve alignment, analytical models serve diagnosis, executable models serve automation — and mixing the three in one canvas produces a diagram nobody can read. Collapse detail into a sub-process rather than flattening it, use call activities when a process is genuinely reused, and resist the urge to draw every exception on the happy-path diagram.

Third, naming carries the meaning. Verb-noun tasks, question-form gateways, state-change events, and consistent pool and lane names do more for comprehension than any layout polishing. A reader should be able to trace a token from start to end and narrate the process out loud without consulting a legend.

Finally, notation is a means, and text is a means of producing it. Writing BPMN in PlantUML keeps the model in version control, makes differences reviewable like code, and lets diagrams be generated and refactored rather than redrawn — which means they stay accurate as the process changes.

Used with that discipline, BPMN stops being a drawing exercise and becomes what its name promises: a notation that business and IT can genuinely share. The three examples in this article are deliberately small, but each one contains the patterns that scale — external participants, internal handoffs, conditional routing, event-driven waits, and exception paths. Build those patterns correctly at the small scale, and the enterprise-scale models will follow.