BPMN Diagrams – How To Use Subprocesses

bpmn diagram

This article shows how to use the different types of subprocesses in BPMN diagrams. Examples of normal subprocesses, looping, multiple instance, ad hoc, and compensation subprocesses.


We presented an introduction to BPMN diagrams two weeks ago. Business analysts are often required to document as-is processes and to-be processes. These diagrams help identify the scope of a software project. The diagrams can also help uncover requirements that might be overlooked without diagramming the processes.

The BPMN specification is designed to establish a common language and convention for creating process diagrams. This common convention allows people who are familiar with modeling, but new to a project to avoid learning a new diagramming language on each project or for each client. We have a link to the official version of the spec in our introductory post (we will update that link if and when the spec changes).

Subprocesses are one of two types of activities that can be included in a BPMN diagram. Each subprocess represents a set of activities – in fact, an entire process segment – within a business process. The other type of activity that we can represent is a task. This article focuses on subprocesses.

Why Use Subprocesses?

The most important element of business process modeling is communication. We communicate with stakeholders to get validation of the processes. We also communicate with the implementation team to assure that the software meets the customer’s requirements.

Stakeholders do not want to try and read incredibly complex multi-page diagrams. Developers need more details than a simple six-box diagram. Subprocesses allow us to achieve both types of communication.

We can create a simple diagram with subprocesses for the stakeholders, and then expand those subprocesses for the developers.

BPMN Subprocesses

There are eleven different types of subprocesses that are defined within the BPMN specification. Six of those subprocess types are essentially the same as their task counterparts (see previous article onhow to diagram BPMN tasks).
These subprocesses are the same as the equivalent tasks.

  • Normal
  • Loop
  • Multiple Instance
  • Compensation
  • Loop Compensation
  • Multiple Instance Compensation

Subprocesses represent a collection of activities (and gateways and flows) being represented collectively as a single activity. There are times when the sequence of activites is undefined, or ad hoc. There is a subprocess type defined expressly for that purpose – the ad hoc subprocess. The ad hoc behavior can also be described for a compensation activity, for either type of looping activities (sequential and parallel), and for looping compensation activities.

The ad hoc subprocesses are enumerated as follows:

  • Ad hoc – a collection of activities without a prescribed order or flow.
  • Ad hoc Loop – an ad hoc subprocess that iterates sequentially.
  • Ad hoc Multiple Instance – an ad hoc subprocess that iterates in parallel with itself.
  • Ad hoc Compensation – an ad hoc subprocess that is triggered as a compensation for a specific activity.
  • Ad hoc Loop Compensation – an ad hoc subprocess that iterates sequentially when triggered as a compensation.
  • Ad hoc Multiple Instance Compensation – an ad hoc subprocess that iterates in parallel when triggered as a compensation.

BPMN Subprocess Legend
bpmn diagram subprocess legend

We will address the five distinct types of subprocesses highlighted in grey in the above. The remaining six subprocesses exhibit the combination of defined behaviors.

Normal Subprocess

The following example is a business process model for eating an OREO.

BPMN Diagram subprocess example

On the left, we have a single swimming pool and swim lane, with a simple, three-step process. The second step, “Eat OREO” provides enough information at a high level for our stakeholders. Note the small plus sign at the bottom of the rectangle – this indicates that “Eat OREO” is a subprocess that can be expanded. The expansion is on the right. The subprocess provides our developers with enough information to know that OREOs must be eaten by first eating the filling and then eating the cookies.

Loop Subprocess

A subprocess can also be a looping activity, which behaves the same way as a looping task. The only difference is that the entire subprocess is repeated instead of a single atomic task being repeated.

BPMN Diagram Loop Subprocess example

On the left, we now represent a business process for eating multiple OREOs. The “Eat OREOs” subprocess has the curved arrow symbol to indicate that it is a looping subprocess. The “Eat OREO” subprocess is repeated sequentially until complete. The center diagram shows the subprocess – note the curved arrow at the bottom of the bounding rectangle – indicating that this subprocess loops.

The “Eat Cookies” activity is also a subprocess, expanded in the rightmost diagram. Subprocesses can contain other subprocesses.

Multiple Instance Subprocess

Just as the multiple instance task allows for looping in parallel, the multiple instance subprocess allows for parallel execution of the subprocess. If we were to eat more than one OREO at a time, we could use the multiple instance subprocess instead of the loop subprocess.
Compensation Subprocess

We explained the behavior of a compensation task in our earlier post on using tasks. We’ve modified that example to demonstrate that the behavior for a compensation subprocesses is the same as for a task. The only difference is that the defined subprocess is executed, instead of the atomic task.

BPMN Diagram Compensation Subprocess example

The compensation subprocess, “Credit Buyer” is triggered by the compensation event that is thrown when the buyer is unhappy with the purchase. The diagram on the top (including swim lanes for both the buyer and seller) clearly shows the process at a high level. The expanded subprocess below shows that there is a complex process for crediting the buyer. The subprocess shows that based on a complex criteria, the seller will either refund cash, reverse credit card charges, or give the buyer a store credit.

Ad hoc Subprocess

An ad hoc subprocess is one in which the specified steps are defined, but the order of operations is not.
BPMN Diagram Ad hoc subprocess example

From the business process modeling diagram on the left, we see that after inviting the guests, we execute a subprocess called “Clean House” and then the flow moves on to “Have Fun.” The subprocess box has a symbol that looks like a tilde (~), indicating that the subprocess is an ad hoc subprocess.

The three tasks within the subprocess are “Clean Kitchen”, “Mow Yard”, and “Clean Diningroom.” There is no specification of the sequence in which these activities are performed. This type of representation is common for documenting of manual processes that do not have defined sequences.

Combination Subprocesses

We also have the combination processes, such as an Ad hoc Loop Compensation subprocess. These combinations apply all of the behavior of all of the unique types they represent. For example, an Ad Hoc Loop subprocess would repeat multiple times, but the order of the steps within each iteration of the subprocess would be undefined.


Business process modeling subprocesses are very effective for communicating a summary or high level process definition to stakeholders, while also supporting the needed details for the implementation team.

3 thoughts on “BPMN Diagrams – How To Use Subprocesses

  1. Regarding Ad Hoc processes:

    The BPMN covers ad hoc SUB-processes (by use of the tilde). But what about top-level processes? Especially for larger scale systems, processes at the top-most “big picture” level can happen in any order and/or all at the same time. How does BPMN handle such?

    It would seem that just using the tilde convention at the “big-picture” level would not be nearly adequate: Some work must be done to show how the top-level processes interrelate.

    Tony Markos

    1. Hey Tony,

      Thanks for the great comment. It has been quite a while since I’ve personally done anything with BPMN, so please take my thoughts with a shaker of salt.

      I think the collection of top level processes, any of which can be initiated arbitrarily, should be treated as independent (or interdependent, if they are) processes. I think by definition, a top-level process is implicitly ad-hoc.

      If however, you do need to model the possibility of concurrent processing, I would suggest creating a “root” top level process like “Run the Business” within which each “top level process” is treated as a sub-process.

      What do you think?

  2. Scott:

    Thanks for the response! I can see how employing a single root-level top-most process and then putting the original top-level processes underneath that root will enable an analyst to then utilize the BPMN notation of a tilde to indicate that the orginal processes can all execute ad hoc.

    However, doesn’t some additional work need to be done, other using than the tilde, to document how all the orginal processes interrelate? If so what?

    Tony Markos

Leave a Reply

Your email address will not be published. Required fields are marked *