Announcing New Book - BPMN Quick and Easy

Today my new book BPMN Quick and Easy Using Method and Style was published. You can get it on Amazon, and a Kindle Textbook version should follow next week. Where BPMN Method and Style 2nd Edition was a comprehensive reference, the new book is slimmed down, focusing on just the elements today's process modelers need to know. Based on the experience of delivering Method and Style training to thousands of students, it simplifies the BPMN vocabulary, methodology, and the style rules. It tries to make creating Good BPMN - models that reveal the process logic clearly and completely from the printed diagrams alone - as streamlined and "mechanical" as possible. The Preface below explains...


In the six years since its publication, BPMN Method and Style 2nd Edition[1] has become the standard reference for process modelers using the Business Process Model and Notation (BPMN) standard. But over those six years, having delivered BPMN Method and Style training to over 4000 students, I’ve learned a lot about which parts of the standard are useful and which are best ignored. Where the previous book sought to explain everything in the BPMN spec – with Method and Style layered on top – BPMN Quick and Easy seeks to streamline, presenting just those things process modelers need to know. Someone once said, “I would have made it shorter if I had more time.” I’ve had six years now, so it’s shorter.

While other business process standards have come and gone – remember BPEL, anyone? – and related ones, like CMMN and DMN, have yet to reach mass adoption, BPMN has become pervasive and remains in wide use today, a good fifteen years after it was originally conceived. That is quite an achievement. And the fact that its primary audience is business users, given their notorious resistance to standards of any sort, is equally impressive.

The main purpose of BPMN is to communicate process logic visually, through diagrams that can be shared and discussedcollaboratively, in real time. But that was not the main objective of the BPMN 2.0 task force in the Object Management Group (OMG) back in 2009 when they drafted the spec. Their concern then was unifying the diagramming notation of BPMN 1.2 – already in wide use by process modelers – with precise execution semantics, creating a visual programming language for process automation that could be shared by business and IT. And it’s fair to say they succeeded in that, as process automation engines not based on BPMN have fallen by the wayside.[2]

But only a small fraction of BPMN models are used for process automation. Most process modelers don’t care a whit about that. They are merely trying to document their current-state process, analyze it for improvement, or redesign it to make it better. And so all those execution-related details crammed into the BPMN 2.0 spec are irrelevant to how the standard is actually used.

For the vast majority of BPMN users, the only thing that counts is what you can see in the diagrams. The process logic – how the process starts and ends, the order of its activities, and its interactions with things outside – should be clearly understandable to anyone from the printed diagrams alone, and not just to those who already know how the process works. At the same time, the process logic captured in those diagrams should be precise and complete. BPMN is not for creating sketches to accompany a detailed text-based process description. Who reads those things, anyway? No. The diagrams are the process model.


That describes the goal, but unfortunately most process models being created by project teams fail that objective. They are Bad BPMN. They do not faithfully communicate the modeler’s intent. They leave important information out. They can be understood only by those who already know how the process works. And thus the team’s huge investment in gathering the information that the model seeks to capture – all those stakeholder workshops and interviews – is, to be honest, wasted.

In this book you’re going to learn how to create Good BPMN, models that fulfill the objective of clear and complete communication of the process logic. This does not require a technical background, but it does require attention to detail and following the rules. Ultimately process modeling is not meant to be a creative exercise but a disciplined one. While creativity is useful for process improvement or redesign, it is not needed for translating the workings of your process from text into diagrams that everyone can understand. And it’s this that is the focus of this book.

Good BPMN means process models that are:

  1. Correct, according to the concepts, semantics, and rules of the BPMN 2.0 spec
  2. Clear, so that the process logic is evident to anyone from the printed diagrams alone, without reference to model information hidden in non-visual elements or in attached text documents
  3. Complete, revealing not only the order of process activities but how the process starts, its possible end states, and all its interactions with things outside: other processes, the requester, service providers, etc.
  4. Consistent in model structure; given the same set of facts about the process logic, all modelers should create more or less the same set of diagrams
Good BPMN, as I have described it, was never a focus of the BPMN 2.0 task force in 2009, and thus the rules of the spec do not attempt to provide it. The spec deals only with item 1 in the list above. Items 2-4 are not addressed. Those require a methodology and additional rules beyond those laid out in the spec. I call mine Method and Style. In this book you’ll learn not only the vocabulary of BPMN, the meaning of the shapes and symbols as defined in the spec, but Method and Style as well.

Changes from BPMN Method and Style, 2nd Edition

BPMN Method and Style, 2nd Edition still remains the authoritative reference on BPMN 2.0. Available in English, German, Japanese, and Spanish, it describes not only all the shapes and symbols but the non-visual elements also captured in the XML serialization. Because it is comprehensive, addressing implementers and developers in addition to process modelers, it possibly implies to a beginning process modeler that BPMN is more complicated than it really is.

When I wrote it in 2011, I had already trained a few hundred students using the Method and Style approach. Today, I have trained over 4000, using a variety of BPMN tools. I’ve seen what students like and don’t like, and I’ve adapted the training accordingly. If you’ve read BPMN Method and Style or took my training a few years ago, you might notice that my advice today sometimes differs from what I said in the past. That’s true. I am continually trying to make the practice of Good BPMN simpler, more “mechanical” and systematic.

For example, the BPMN spec often gives the modeler multiple ways to diagram the same behavior. I used to teach all the ways; now I see it’s better to teach just one way, and BPMN Quick and Easy does just that. So you won’t see things like activities with multiple outgoing sequence flows, conditional sequence flows, or implicit start and end nodes. Not only are they gone from the book and training, but new style rules warn you away from them. The spec also includes shapes and symbols that are useful only on rare occasions and almost never used correctly. So they’re gone, too: Signal events, Conditional events, and Link events... most process modelers can live without them.

Some things have been added. With the new Decision Model and Notation (DMN) standard, BPMN’s decision task – officially called business rule task – now has some real utility, so we talk about how to use it to improve the BPMN. Event subprocesses and data stores now play more prominent roles in my BPMN Method and Style training, and so they do in the new book, as well.

Message events have always been somewhat problematic because in the spec they mean system-to-system communications to and from the process engine, while in non-executable modeling they are used for any one-way communication between a process element and something outside the process. So should the lane of a Message end event imply the sender of the message? The spec says no, but for months students berated me about this. BPMN Quick and Easy resolves this conflict.

What You’ll Learn

In this book, you’re going to learn three things:
  1. The vocabulary of BPMN, the shapes and symbols, and how to use them correctly. We’re going to focus on just those that you really need to know.
  2. A methodology for taking process information gathered from stakeholder interviews and workshops, and reorganizing it into Good BPMN. It is impossible to create Good BPMN live in real time with the stakeholders. It is a post-process, a “refactoring” of the information. The Method is a systematic five-step procedure for doing that.
  3. BPMN Style, additional rules beyond those of the spec, intended to make the process logic clearly understood from the printed diagrams alone. Conforming to the style rules is most easily achieved with BPMN tools that include them in the validation, as do Vizi Modeler from itp commerce, Trisotech BPMN Modeler, and Signavio.

BPMN Tools

While simple BPMN diagrams can be drawn by hand, BPMN assumes use of a software tool. The good news is that there are many such tools to choose from, and the meaning of the diagram is the same with any tool. But even though BPMN is a standard, the tools are not all equally good. Some are really drawing tools, not modeling tools. They can produce diagrams containing the standard shapes and connectors, but the tools do not “understand” their meaning. They cannot, for example, validate the model, or save it in the BPMN standard XML interchange format. If you are serious about process modeling, you need to use a tool that can at least validate your model against the rules of the spec and interchange models with other BPMN tools.

Some BPMN tools are intended for process modelers – business analysts, business architects, and ordinary business users – while others are intended for developers creating automated processes. For most readers of this book, those intended for process modelers will be much easier to use. The great thing about BPMN being a standard is that business and technical users don’t need to use the same tool. Models can be interchanged between compliant tools without loss of fidelity. The BPMN Model Interchange Working Group (MIWG)[3] provides a set of tests for model interchange and regularly updates its list of compliant tools (Figure 1‐1).

Figure 1‐1. BPMN MIWG tests tool support for model interchange

The best BPMN tools (in my opinion) include built-in support for Method and Style. There are currently three that I know of:

  • Vizi Modeler from itp commerce is an add-in to Microsoft Visio 2010 or later. An earlier version was called Process Modeler for Visio. Vizi Modeler includes wizard-based model generation following the Method and its model validation feature checks both the spec rules and the style rules.
  • Trisotech BPMN Modeler is a cloud/browser-based tool. Style rule validation is built into its toolbar, and the tool integrates BPMN with companion DMN and CMMN models.
  • Signavio also provides a cloud/browser-based tool, with style rule validation built in.
Illustrations in this book were created using both Vizi Modeler and Trisotech.

Beyond Book Learning

BPMN is a new language. You can learn to read it well simply by reading this book. Learning to write it, however, generally requires more than book learning. It requires practice, and testing your knowledge.

An inexpensive and easy way to get practice is through bpmnPRO, a gamification-based eLearning app modeled after Duolingo, a popular iOS language app. It involves no tools or lecture. bpmnPRO teaches BPMN Method and Style entirely through quiz questions and puzzles.

Becoming truly proficient in BPMN, however, requires a bit of training, connecting the book learning or lecture material with hands-on experience using a tool. BPMN Quick and Easy provides many diagram examples, and I encourage readers to reproduce them using a BPMN tool. Like any skill, you really learn BPMN only by doing it, working through the creation of diagrams that faithfully represent some given process scenario. In other words, you need a bit of BPMN training.

There is an old joke about sex education vs. sex training that I won’t repeat here. But you get the idea. Training involves practice, exercises and discussion of solutions, why certain ways work better than others. I provide BPMN Method and Style training, both live and online, in various formats and using a variety of tools[4]. This book could be used as a reference for that training, or as a textbook in a college course on BPMN, but by itself it is not training.

Structure of the Book

The organization of the book largely follows that of my BPMN Method and Style training.

Chapter 1, What Is BPMN?, discusses four key differences between BPMN and traditional swimlane flowcharts, which it outwardly resembles. It also explains the limitations of BPMN, the types of processes it cannot describe, and the aspects of process modeling that are outside its purview. It explains the real meaning of BPMN’s most fundamental concepts – activity and process – and the issues that arise when BPM Architecture and other segments of the BPM domain use those terms much more loosely.

Chapter 2, BPMN by Example, builds up an order process bit by bit using elements of the Level 1 working set, mostly shapes carried over from traditional flowcharting. Readers learn the meaning and basic usage of tasks and subprocesses, start and end events, gateways, pools, and lanes, and message flow. At the same time, they learn the basics of Method and Style, including process levels and end states, with label matching between gateways in the parent level and end states in the child level. They learn the three possible ways a process can start, and how that tells you what the process instance represents.

Chapter 3, The Method, deals with the real challenge of process modeling: translating the tangle of process details gathered from stakeholder interviews and workshops into properly structured BPMN that communicates the process logic clearly from the printed diagrams alone. The Method is a systematic five-step procedure. It is not done in real time with the stakeholders, but involves carefully reorganizing that information afterwards in top-down fashion.

Chapter 4, BPMN Style, explains why the rules of the BPMN spec are inadequate to ensuring Good BPMN and the benefits of formulating Good BPMN practices as additional style rules that can be validated by tools. It then explains the most important style rules, illustrating both violations and correct BPMN style.

Chapter 5, DMN and Decision Tasks, discusses why embedding decision logic in process models as a chain of gateways is Bad BPMN, and how integrating BPMN with the new companion standard DMN fixes the problem. The chapter includes a tutorial on DMN basics, and provides a simple procedure for transforming embedded decision logic into a decision task (aka business rule task) invoking a DMN decision, followed by a single gateway.

Chapter 6, Parallel Flow, explains the concepts and issues of conditionally parallel flow using OR gateways, and use of the proper gateway to merge sequence flows, depending upon whether they are exclusive alternatives, unconditionally parallel, or conditionally parallel.

Chapter 7, Events, discusses common usage patterns with the Big 3 event types: Timer, Message, and Error. Readers learn how to model deadline-triggered actions, wait for a message or a timeout, handle cancellation or update of a process in flight, and use error throw-catch patterns. The main focus is on intermediate events, but the chapter also describes the use of event subprocesses.

Chapter 8, Instance Alignment, returns to an issue introduced in Chapter 1, the spec’s requirement that the instance of every activity in a BPMN process must correspond 1:1 with the process instance. That means, for example, that in a process where the instance is an order, every activity must be performed once per order, not once a day or once a batch of orders. Of course, batching is commonplace in real processes, and this chapter discusses various ways to handle it: loop and multi-instance activities, multi-process structures, and non-interrupting event subprocesses.

Chapter 9, Becoming Proficient, discusses how to go beyond “book learning” and become really proficient at Good BPMN. It takes practice, testing your understanding, and hands-on experience with real tools. Training including certification is usually a big help.

Bruce Silver October 2017


[2] The spec is freely available at


[4] For more information, see