Events

While tasks represent what needs to be done to achieve the goal of a process, events describe asynchronous interactions between the process and the external world.

Intermediate Events

Edit(event)

The event label is written between the round parenthesis (event).

By default, untyped events are shown as intermediate events.

Depending on the event type, the first event of a sequence may become a start event and the last event of a sequence may become its end event.

Start and End Events

Start events represent the beginning of the process execution and describe when a process should start. End events are reached when processes finish their execution.

EditTask

By default, BPMN Sketch Miner automatically adds start and end event to each sequence of tasks.

Edit(start Begin)
Task
(finish Done)

To describe them in more detail, just mention them explicitly in the text at the beginning or at the end of each sequence of tasks using the start and finish keywords.

Timer

Timer events represent literally when (which date, at what time, how often) a process will start.

Edit(timer every morning)
Eat Breakfast

Timer events can also be found within a process. In this case they are used to explicitly represent a delay in the process execution.

EditEat Lunch
(timer 2hr)
Go Swimming

Error

Error events indicate that a process failed.

Edit(error Missing Data)

Message

Message events represent interactions with exactly one external communication party. From the perspective of the process, messages can be sent (black envelope symbol) or received (white envelope symbol).

Edit(receive Message)

A process starts when a message is received.

Edit(send Message)

A process completes after a message has been sent.

Edit(send Message)
(receive Reply)

After a message has been sent, a process waits until a reply message is received.

Note that a process cannot start by sending a message or end by receiving one. This is why - when listed in this order - the two events are kept as intermediate events.

Signal

Signal events also represent an external interaction, which unlike messages may involve multiple parties (as in broadcast or multicast communication).

We use the terms publish to indicate throwing a signal and notify to indicate catching the arrival of the signal and the corresponding notification of the process.

Edit(notify Signal)

A new process instance is triggered by a signal.

Edit(publish Signal)

A process completes by broadcasting a signal.

Edit(publish Signal)
(notify Reply)

After a signal has been broadcast, the process waits for the notification of another signal.

Escalation

Escalation events identifies a business situation that a process might need to react to.

Edit(escalate Contact The Ground Staff)

This process does not normally complete, instead it requires to escalate processing elsewhere.

Edit(escalate Flight Delayed more than 2hr)
(finish)

Unlike an error, an escalation event is non critical. Process execution can continue and still reach a successful conclusion.

Terminate

Terminate events stop the execution of the process, even if other parallel execution branches may not have been yet finished.

Edit(start)
A|B
(finish)|(terminate)

If task A finishes first, the process will wait for B to finish. However as soon as B is complete, the process will end (even if A is still running).

Boundary Events

Boundary events help to deal with events happening during the execution of a task.

EditTask
(deadline)

Task
((deadline))

Boundary events always follow the task they should be attached to.

How to distinguish boundary events from the other events? Use the following event types: deadline, exception, received, escalated. You have to explicitly pick one of these if you want to model a boundary event.

There are two kinds of boundary events: interrupting (continuous border) and non-interrupting ((dashed border)).

Interrupting boundary events

When these events occur, the normal execution of the task is interrupted and the process control flow continues from the boundary event.

EditSend Order
Receive Confirmation

...
Receive Confirmation
(deadline 1 day)
Cancel Order

EditPrepare Order
Send Order
Receive Confirmation

...
Receive Confirmation
(deadline 1 day)
Send Order
...

Interrupting boundary events are written within a single set of round parenthesis ( ).

Non-interrupting boundary events

Catching these events will not interrupt the normal execution of the task.

EditProcess Order
Deliver Shipment

Process Order
((deadline 30m))
Announce Delay

Non-interrupting boundary events are written within a double set of round parenthesis (( )).

More Examples