Skip to main content
Image coming soon

Deeper command of the BPMN 2.0 execution standard

$199.00
Adding to cart… The item has been added

A tailored course, built for your situation

Deeper command of the BPMN 2.0 execution standard

Master the underlying framework to design, validate, and hand off process models that require no rework

$199 one-time
24-hour access provisioning 30-day money-back guarantee Hand-built implementation playbook
12 modules. 12 chapters per module. 144 chapters total.
12 modules, each with 12 chapters (144 chapters total), text-based, plus downloadable templates and a hand-built implementation playbook delivered alongside course access.

Who this is for

Process Specialist at a global services firm, responsible for designing, documenting, and handing off BPMN-compliant process models across client engagements. Works across industries with variable automation maturity. Uses tools like Signavio, ARIS, or Bizagi, but needs models that go beyond diagramming to execution readiness.

Who this is not for

Those looking for high-level 'process thinking' or general Lean Six Sigma refreshers. This course is not about facilitation, stakeholder alignment, or swimlane basics. It’s for practitioners who already model daily and want to master the technical standard underneath.

What you walk away with

  • Author BPMN 2.0 models with correct execution semantics for gateways, events, and subprocesses
  • Validate model conformance to ISO 19510 using lightweight tool-agnostic checks
  • Eliminate rework loops caused by ambiguous diagram interpretation
  • Hand off models that development teams can ingest directly into automation platforms
  • Build personal validation templates that enforce execution-grade consistency across engagements

The 12 modules (with all 144 chapters)

Module 1. BPMN 2.0 core elements and conformance classes
Break down the BPMN 2.0 specification into execution-relevant components: flows, activities, events, gateways, and data objects. Focus on formal conformance classes (Basic, Collaborative, Executable) and how they impact downstream use.
12 chapters in this module
  1. Core element taxonomy
  2. Flow objects vs connecting objects
  3. Data associations and artifacts
  4. Executable vs descriptive models
  5. ISO 19510 conformance levels
  6. Tool support mapping
  7. Execution semantics definition
  8. Process vs collaboration diagrams
  9. Event boundary placement
  10. Subprocess nesting rules
  11. Message flow validation
  12. Lane set structuring
Module 2. Gateway logic and execution paths
Master the behavior of exclusive, inclusive, parallel, and event-based gateways under real execution conditions. Learn how engines interpret branching rules and avoid common logic traps.
12 chapters in this module
  1. Exclusive (XOR) gateway rules
  2. Inclusive (OR) activation conditions
  3. Parallel (AND) split/merge
  4. Event-based gateway timing
  5. Default flow handling
  6. Sequence flow evaluation
  7. Implicit vs explicit joins
  8. Dead path suppression
  9. Mixed gateway sequences
  10. Error escalation routing
  11. Conditional event triggers
  12. Timer boundary integration
Module 3. Event types and boundary handling
Distinguish between start, intermediate, and end events, and how boundary events alter task behavior. Model interrupting vs non-interrupting events with precision.
12 chapters in this module
  1. Start event triggers
  2. Intermediate catch/throw
  3. End event types
  4. Boundary event attachment
  5. Interrupting vs non-interrupting
  6. Timer event configuration
  7. Error event definitions
  8. Signal event scoping
  9. Message event correlations
  10. Compensation event use
  11. Escalation event routing
  12. Conditional event logic
Module 4. Subprocesses and call activities
Structure embedded and reusable subprocesses correctly for execution. Understand how variables, events, and transactions propagate across boundaries.
12 chapters in this module
  1. Embedded subprocess rules
  2. Transactional subprocess
  3. Call activity referencing
  4. Reusable subprocess design
  5. Variable scope inheritance
  6. Event propagation rules
  7. Compensation handling
  8. Async execution markers
  9. Loop and multi-instance
  10. Ad-hoc subprocess use
  11. Subprocess monitoring
  12. Versioning and reuse
Module 5. Data objects and flow semantics
Model data inputs, outputs, and intermediate states with execution-grade clarity. Connect data to tasks and gateways without ambiguity.
12 chapters in this module
  1. Data object definition
  2. Input/output specifications
  3. Data store modeling
  4. Data association rules
  5. Data-driven gateways
  6. Task input validation
  7. Output mapping syntax
  8. Data context scoping
  9. Variable lifecycle
  10. Data-based routing
  11. State change triggers
  12. Integration point labeling
Module 6. Message flows and collaboration diagrams
Design cross-participant interactions with correct message sequencing, correlation, and error handling. Avoid sequence mismatches in distributed processes.
12 chapters in this module
  1. Participant definition
  2. Pool and lane usage
  3. Message flow direction
  4. Sequence vs message flow
  5. Correlation key setup
  6. Message event triggers
  7. Request-response patterns
  8. Asynchronous messaging
  9. Error escalation paths
  10. Timeout handling
  11. Message validation rules
  12. Cross-system interaction
Module 7. Execution semantics in real engines
Map BPMN diagrams to how Camunda, IBM BAW, and Pega interpret them. Identify where tool defaults diverge from the standard.
12 chapters in this module
  1. Engine parsing behavior
  2. Camunda execution rules
  3. IBM BAW interpretation
  4. Pega activity mapping
  5. Tool-specific extensions
  6. Non-standard attribute use
  7. Execution log alignment
  8. Simulation output reading
  9. Timer job handling
  10. Async continuation
  11. Transaction boundaries
  12. Error recovery modes
Module 8. Validation techniques and rule checking
Apply a systematic checklist to verify model correctness before handoff. Catch structural flaws, logic gaps, and conformance issues early.
12 chapters in this module
  1. Structural completeness
  2. Gateway balance check
  3. Event pairing rules
  4. Subprocess closure
  5. Lane consistency
  6. Flow continuity
  7. Data object linkage
  8. Message correlation
  9. Timer expression syntax
  10. Error boundary coverage
  11. Compensation scope
  12. Validation report format
Module 9. Tool-specific modeling pitfalls
Recognize how Signavio, ARIS, and Bizagi introduce rendering or export quirks that break execution readiness. Adjust modeling habits to compensate.
12 chapters in this module
  1. Signavio export behavior
  2. ARIS modeling shortcuts
  3. Bizagi execution mode
  4. Default gateway settings
  5. Event type mismapping
  6. Subprocess flattening
  7. Data object omission
  8. Lane set export issues
  9. Message flow labeling
  10. Tool-specific annotations
  11. Version compatibility
  12. Import/export validation
Module 10. Handoff protocols for dev teams
Structure model delivery packages so development teams can ingest them directly. Include execution notes, assumptions, and validation results.
12 chapters in this module
  1. Model packaging format
  2. Execution assumptions doc
  3. Validation checklist attach
  4. Variable dictionary
  5. Error handling spec
  6. Timer configuration
  7. Message correlation table
  8. Data mapping guide
  9. Version control tagging
  10. Change log inclusion
  11. Dev Q&A pre-empt
  12. Feedback loop integration
Module 11. Simulation and test-readiness prep
Prepare models for simulation by defining inputs, paths, and success criteria. Use lightweight techniques to validate logic before automation.
12 chapters in this module
  1. Simulation input setup
  2. Path coverage analysis
  3. Success criteria definition
  4. Error path modeling
  5. Timer scenario testing
  6. Data variation testing
  7. User task simulation
  8. System task mocking
  9. Integration point stubs
  10. Log output prediction
  11. Performance benchmarking
  12. Test case derivation
Module 12. Personal playbook for execution-grade modeling
Compile your own reusable standards, templates, and validation rules. Build a personal library that ensures consistency across all future engagements.
12 chapters in this module
  1. Template library creation
  2. Style guide definition
  3. Validation checklist
  4. Common pattern archive
  5. Error handling playbook
  6. Tool-specific adjustments
  7. Client-specific rules
  8. Version management
  9. Knowledge transfer kit
  10. Peer review checklist
  11. Automation readiness score
  12. Continuous improvement loop

How this maps to your situation

  • Designing a process model for handoff to automation team
  • Reviewing a client’s existing BPMN model for execution readiness
  • Creating a standardized modeling approach across multiple engagements
  • Reducing back-and-forth between process and dev teams

Before vs. after

Before
Models require multiple rounds of review and reinterpretation before development can begin. Logic gaps surface during build, causing delays and rework.
After
Models are execution-ready on first delivery. Development teams ingest them directly, with clear rules, data flows, and error handling already defined.

What's included with your purchase

  • 12 modules with 12 chapters each (144 chapters)
  • Downloadable templates and worked examples for every module
  • Hand-built implementation playbook delivered alongside course access
  • 30-day money-back guarantee

Delivery and format

  • Course and learning environment access provisioned within 24 hours of purchase
  • Hand-built implementation playbook delivered alongside course access

Format: Text-based modules and chapters in the Art of Service learning environment, plus downloadable templates and worked examples for every chapter, plus the hand-built implementation playbook delivered alongside course access.

Time investment: Approximately 3-4 hours per module, with self-paced progression. Most practitioners complete the course in 6-8 weeks while working full-time.

How this compares to the alternatives

Generic BPMN courses focus on diagramming syntax and swimlane layout. This course goes deeper, into execution semantics, engine behavior, and validation rigor. Unlike vendor-specific training, it’s grounded in the open standard, making your skills portable across tools and platforms.

Frequently asked

Is this about diagramming or execution?
This is about execution. You’ll learn how BPMN 2.0 models are interpreted by automation engines, not just how to draw them.
How is the course structured?
12 modules, each containing 12 chapters (144 chapters total).
Will this work with my current tools?
Yes. The course focuses on the standard itself, then maps it to how Signavio, ARIS, Bizagi, Camunda, and others implement it.
$199 one-time. Approximately 3-4 hours per module, with self-paced progression. Most practitioners complete the course in 6-8 weeks while working full-time..

Within 24 hours your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it.

30-day money-back guarantee· 144 chapters· Hand-built playbook included· Account access within 24 hours
!