Skip to Content
Flower 3.7.1 is released 🎉 See what's new
BPMN Reference· 14 min read· Updated November 2026

BPMN Events

Next releaseThis page already describes the next release of Flower BPM: messages and signals from outside, link events that jump, event sub-processes, and message, signal and escalation end events. The tables mark what changes.

In short: An event is something that happens during a process. It is drawn as a circle. The border tells the position: a thin line is a start event, a double line an intermediate event, a thick line an end event. The symbol inside tells the type: an envelope is a message, a clock a timer, a lightning bolt an error.

🛠️

Guide: Trigger Jira Automation sets up throw events, Set Due Dates with Timers sets up deadlines, and End a Process covers end events.

Events in BPMN represent things that happen. A process can react to events (catching events) as well as emit events (throwing events). For example, a catching message event makes the token continue as soon as a message is received.

Events can make a token wait at a certain point, and they can interrupt the progress of a token.

Flower executes a subset of the BPMN events: throw events, timer, conditional, message, signal, error, and escalation boundary events, the intermediate timer, conditional, message, signal, and link events, the timer, conditional, message, and signal start events, event sub-processes with a conditional, timer, error, message, signal, or escalation start event, the none start event, and the none, message, error, escalation, signal, and terminate end events. Message events wait for a message from outside, sent by a comment, Jira Automation, or the REST API, see BPMN Message Events, or for a message flow from another pool of the same model. Signal events wait for a signal of their name, which reaches every waiting process instance at once, see BPMN Signal Events. What happens with each event that Flower does not execute is listed in BPMN Coverage in Jira.

Events in General

Events in BPMN are either thrown (sent) or caught (received). They are called throw events and catch events, for example message throw event or timer catch event.

BPMN distinguishes three positions:

PositionTypePurpose
Start eventCatch event, because it can only react to somethingMarks the beginning of a process or sub-process
Intermediate eventThrow event (something happens) or catch event (wait and react)Sits in the normal flow or is attached to an activity
End eventThrow event, because it indicates that something has happenedMarks the end of a sequence flow

An intermediate catch event can be inserted into the process in two contexts: in the normal flow, or attached to an activity. In the second case it is called a boundary event.

All BPMN Events at a Glance

The table shows every event type of BPMN 2.0 (rows) in every position where the standard allows it (columns). The events that Flower executes are marked in green. All others can be modeled; what Flower does with them is listed in BPMN Coverage. Click a type to read what it does.

StartIntermediateEnd
TypeNormalEvent
Sub
process
Event
Sub
process
non-
interrupt
CatchBoundaryBoundary
non-
interrupt
Throw
None
Start EventCircle
None Intermediate Throw EventDouble circle
None End EventThick circle
Message
Message Start EventCircle with mail symbol
Message Event SubprocessCircle with mail symbol
Message Event Subprocess Non-interruptDashed Circle with mail symbol
Message Event CatchDouble Circle with mail symbol
Message Event BoundaryDouble Circle with mail symbol
Message Event Boundary non-interruptDouble dashed Circle with mail symbol
Message Event ThrowDouble Circle with gray mail symbol
Message End EventThick Circle with gray mail symbol
Timer
Timer Start EventCircle with clock symbol
Timer Event SubprocessCircle with clock symbol
Timer Event Subprocess non-interruptDashed Circle with clock symbol
Timer Event CatchDouble Circle with clock symbol
Timer Event BoundaryDouble Circle with clock symbol
Timer Event Boundary non-interruptDouble Dashed Circle with clock symbol
Conditional
conditional start eventcircle with note symbol
conditional event subprocesscircle with note symbol
conditional event subprocess non-interruptdashed circle with note symbol
conditional catch eventdouble circle with note symbol
conditional boundary eventdouble circle with note symbol
conditional boundary non-interrupt eventdouble dashed circle with note symbol
Link
link catch eventdouble circle with right arrow symbol
link throw eventdouble circle with gray right arrow symbol
Signal
signal start eventcircle with triangle symbol
signal event Subprocesscircle with triangle symbol
signal event Subprocess non-interruptdashed circle with triangle symbol
signal catch eventdouble circle with triangle symbol
signal boundary eventdouble circle with triangle symbol
signal boundary non-interrupt eventdouble dashed circle with triangle symbol
signal throw eventdouble circle with gray triangle symbol
signal end eventthick circle with gray triangle symbol
Error
error event subprocesscircle with lightning symbol
error boundary eventdouble circle with lightning symbol
error end eventthick circle with gray lightning symbol
Escalation
escalation event subprocesscircle with compass arrow symbol
escalation event subprocess non-interruptdashed circle with compass arrow symbol
escalation boundary eventdouble circle with compass arrow symbol
escalation boundary non-interrupt eventdouble dashed circle with compass arrow symbol
escalation throw eventdouble circle with gray compass arrow symbol
escalation end eventthick circle with gray compass arrow symbol
Terminate
termination end eventthick circle with a solid gray circle
Compensation
compensation event subprocesscircle with rewind symbol
compensation boundary eventdouble circle with rewind symbol
compensation throw eventdouble circle with gray rewind symbol
compensation end eventthick circle with gray rewind symbol
Cancel
cancel boundary eventdouble circle with x symbol
cancel end eventthick circle with gray x symbol
Multiple
multiple start eventcircle with pentagon symbol
multiple event Subprocesscircle with pentagon symbol
multiple event Subprocess non-interruptdashed circle with pentagon symbol
multiple catch eventdouble circle with pentagon symbol
multiple boundary eventdouble circle with pentagon symbol
multiple boundary non-interrupt eventdouble dashed circle with pentagon symbol
multiple throw eventdouble circle with gray pentagon symbol
multiple end eventthick circle with gray pentagon symbol
Multiple Parallel
multiple parallel start eventcircle with plus symbol
multiple parallel event subprocesscircle with plus symbol
multiple parallel event subprocess non-interruptdashed circle with plus symbol
multiple parallel catch eventdouble circle with plus symbol
multiple parallel boundary eventdouble circle with plus symbol
multiple parallel boundary non-interrupt eventdouble dashed circle with plus symbol

The green message events that wait receive a message from outside (a comment, Jira Automation, or the REST API, see BPMN Message Events) or over a message flow between the pools of the same model. The green signal events that wait receive a signal from a comment, Jira Automation, the REST API, or a signal throw or end event of another process, see BPMN Signal Events. The green error end event works inside an embedded sub-process or a called model.

How to read the columns:

  • Start: the event begins a process (Normal) or an event sub-process, which either interrupts its parent or runs next to it (non-interrupt, dashed border).
  • Intermediate, Catch: the process waits in the flow until the event happens.
  • Intermediate, Boundary: the event sits on the border of an activity and reacts while the activity runs. Interrupting, it cancels the activity. Non-interrupting (dashed border), the activity goes on.
  • Intermediate, Throw: the process makes the event happen and goes on. The symbol is filled.
  • End: the path ends and the event happens. The symbol is filled.

Supported Events at a Glance

Start events, events on the border of a task, events in the flow and end events: what Flower does with each, and when a boundary event fires.
Event typeSupported in FlowerWhat happens
NoneStart, intermediate throw, endStart: the process starts. Throw: Flower triggers a Jira Automation rule (Forge) or calls a webhook URL (Connect, Data Center), then goes on. End: the flow ends
MessageIntermediate throw, end, intermediate catch, boundary (interrupting and non-interrupting), start, event sub-process; the receive taskCatch, boundary, start, and event sub-process: the process waits for the message of its name, sent by a comment @FlowerBPM <name>, Jira Automation, or the REST API, or by a message flow of the same model. Throw and end: Flower triggers a Jira Automation rule (Forge) or calls a webhook URL (Connect, Data Center). With a message flow to another pool of the model, the message goes to that pool instead (a message flow to a black box pool is only documentation)
SignalIntermediate throw, end, intermediate catch, boundary (interrupting and non-interrupting), start, event sub-processCatch, boundary, start, and event sub-process: every process instance that waits for the signal of its name gets it, sent by a comment @FlowerBPM signal <name>, Jira Automation, the REST API, or a signal throw or end event. Throw and end: they send the signal to the waiting process instances, and Flower triggers a Jira Automation rule (Forge) or calls a webhook URL (Connect, Data Center); the end event then ends its flow
EscalationIntermediate throw, end, boundary (interrupting and non-interrupting), event sub-processThrow: Flower triggers a Jira Automation rule (Forge) or calls a webhook URL (Connect, Data Center); inside an embedded sub-process it also reaches the escalation boundary event of the sub-process (in a called model it does not reach the call activity). End: in a called model, the escalation boundary event of the call activity catches it. Boundary (Forge and Data Center): when the work item is moved into the selected Jira status, Flower starts the path of the event. Event sub-process: it starts at an escalation throw or end event of the process
LinkIntermediate throw and catchThe throw event jumps to the catch event with the same link name, the process goes on there
TimerBoundary (interrupting and non-interrupting), intermediate catch, start, event sub-processBoundary: Flower sets the due date of the work item and starts a timeout path. Intermediate and start: the process waits until the timer is due
TerminateEndFlower ends the whole process and closes all open work items
ConditionalBoundary (interrupting and non-interrupting), intermediate catch, start, event sub-processBoundary: when the work item is resolved and the condition (an expression, or a choice of statuses and resolutions) is true, Flower takes the path of the event. Intermediate and start (Forge and Data Center): the process waits until a change of the process instance makes the condition true
ErrorBoundary (interrupting), end event inside an embedded sub-process or a called model, event sub-processBoundary: when the work item is resolved in the selected Jira status, Flower takes the path of the event. End event inside an embedded sub-process or a called model: the sub-process ends and the path of its error boundary event is taken
Compensation, cancel, multiple, multiple parallelNot executed as in BPMNAn intermediate throw event of these types acts like a none throw event, an end event like a none end event, see BPMN Coverage

Every intermediate throw event except link has the same effect, whatever its type (the rule or webhook learns the type: {{issue.properties.flowerAutomation.type}}, {{webhookData.type}}): in the Forge version it triggers a Jira Automation rule (the default, the Forge app does not call URLs), in Connect and Data Center it calls the webhook URL of the event. A throw event without a webhook URL in Connect or Data Center adds an error comment to the process instance (Webhook URL is empty), and the process goes on. See Sync Magic. Of the end events, only the message and the signal end event trigger a rule or a webhook; the others do not.

Intermediate Events

Throw event with a webhook URL in the properties panel

In a typical flow, an intermediate throw event executes its action as soon as the token reaches it: in Flower, it triggers a Jira Automation rule (Forge) or calls a webhook (Connect, Data Center). When it is complete, the token continues to all outgoing sequence flows (1). Read more about throw events and webhooks.

An intermediate catch event stops the token and waits until the awaited event occurs. Then the execution resumes and the token moves on (2). In Flower, the intermediate timer event, the intermediate conditional event (Forge and Data Center), and the intermediate message event and the receive task work this way: a message arrives from outside (a comment, Jira Automation, or the REST API, see BPMN Message Events) or from another pool of the same model. The intermediate signal event waits for the signal of its name, see BPMN Signal Events.

Boundary Events

A boundary event models what should happen if an event occurs while an activity is active. For example, a user task takes too long. A timer boundary event on the task has an outgoing sequence flow to a notification task, which reminds the user. Read more about timers.

A timer boundary event on an activity and its properties Type Duration and Value P5D, highlighted in red

A boundary event must be an intermediate catch event. It is either interrupting (1) or non-interrupting (2):

  • Interrupting: When the event is triggered, the activity it is attached to ends before the process takes the outgoing sequence flow. Use it to model timeouts that cut off a path, for example when the process takes too long.
  • Non-interrupting: The activity continues, and the process follows both flows.

The example also contains a terminate end event. It ends all parallel flows at once and closes all open work items of the process. See BPMN End Events.

Event Types in Detail

The headings in this section are the link targets of the coverage overview.

None Events

A none event has no trigger.

  • The none start event starts the process.
  • The none end event ends its flow. Parallel flows continue, and the process instance ends when the last flow is done. Then Flower resolves its work item and sets the Jira resolution if the workflow does not, see BPMN End Events.
  • The none intermediate throw event triggers the Jira Automation rule (Forge) or calls the webhook URL (Connect, Data Center), then passes the token on.

Message Events

The message event in BPMN, with all its positions, and how to send a message to a process instance: BPMN Message Events.

The receive task, the intermediate message catch event, the message boundary event (interrupting and non-interrupting), the message start event, and the message event sub-process wait for the message of their name. A person, a Jira Automation rule, or another system sends it: with a comment that starts with @FlowerBPM <name>, with the Jira Automation action Flower: Send message to process (Cloud), or with the REST API (Data Center). Between the pools of one model, a message flow delivers the message of a throw or end event to the other pool, see Message Flows Between Pools.

The message intermediate throw event and the message end event send: Flower triggers a Jira Automation rule (Forge) or sends an HTTP POST request to the webhook URL from the properties panel (Connect, Data Center), and then continues. See Sync Magic.

Timer Events

Flower supports the timer boundary event, interrupting and non-interrupting. It sets the due date of the work item and starts a timeout path when the date passes. You define the timer with an ISO 8601 date, duration, or repeating interval.

Flower also supports the intermediate timer event, which lets the process wait in the flow, and the timer start event, which delays the start of a process instance. Both fire once on their due day. See Set Jira Due Dates with Timer Events.

Timer event sub-processes start on their due day, see Event Sub-Processes in Flower. All timer variants and the ISO 8601 formats are explained in BPMN Timer Events.

Error Events

The error event in BPMN, with all its positions: BPMN Error Events.

Flower supports the error boundary event, the error end event inside an embedded sub-process or a called model, which the error boundary event of the sub-process or call activity catches, and the error event sub-process. An error end event of a process instance that no process called ends it with an error comment. A person throws the error by resolving the work item of the activity in a Jira status, for example Cancelled: you select this status for the event. Flower ends the activity and takes the path of the event instead of the normal one. See End a Task with an Error Status.

Signal Events

The signal event in BPMN, with all its positions, and how to send a signal: BPMN Signal Events.

A signal is a broadcast: it reaches every process instance that waits for a signal of its name, a message only one. The intermediate signal catch event, the signal boundary event (interrupting and non-interrupting), the signal start event, and the signal event sub-process wait for it, also behind an event-based gateway. A person, a Jira Automation rule, or another system sends it: with a comment on any work item that starts with @FlowerBPM signal <name>, with the Jira Automation action Flower: Send signal (Cloud), or with the REST API (Data Center).

The signal intermediate throw event and the signal end event send the signal to every waiting process instance. They also trigger a Jira Automation rule (Forge) or call a webhook URL (Connect, Data Center) like every other throw event; the end event then ends its flow.

Escalation Events

The escalation event in BPMN, with all its positions: BPMN Escalation Events.

Flower supports the escalation intermediate throw event. It works like every other throw event (Jira Automation on Forge, webhook in Connect and Data Center). Inside an embedded sub-process, it also reaches an escalation boundary event on the border of the sub-process; in a called model it does not reach the call activity. The escalation end event of a called model reaches the escalation boundary event of the call activity.

Flower for Jira Cloud on Forge and Flower for Data Center also support the escalation boundary event, interrupting and non-interrupting (the Connect app does not). A person or a Jira Automation rule escalates by moving the work item of the activity into a Jira status, for example Escalated: you select this status for the event. Flower starts the path of the event at once, while the work item is open. See Escalate a Task with a Jira Status. To escalate work that is overdue, use a timer boundary event. The escalation event sub-process starts at an escalation throw or end event of the process, as in BPMN. The Jira status of a work item escalates only the escalation boundary event of its own task, not an event sub-process. See Event Sub-Processes in Flower.

Terminate Events

Flower supports the terminate end event. It ends the whole process instance and closes all open work items. Closing them does not continue the process. See BPMN End Events.

Flower supports link events. A link throw event jumps to the link catch event with the same link name in the same process, like a long arrow: the process goes on after the catch event. It does not trigger a rule or webhook. Several throw events can jump to one catch event. The validator warns about a throw event without a catch event of its name (the process would stop there) and about a catch event that no throw event reaches.

Conditional Events

The conditional event in BPMN, with all its positions: BPMN Conditional Events.

Flower supports the conditional boundary event, interrupting and non-interrupting. When the work item of the activity is resolved, Flower evaluates the condition: a choice of statuses and resolutions of the work item, or an expression like on an XOR gateway. If it is true, the process takes the path of the event, for example Rejected or Cancelled. See Branch on the Outcome of a Task with Conditional Boundary Events. The intermediate conditional event and the conditional start event wait until the condition on the process instance (pi) is true; Flower checks it whenever the process instance changes (Forge and Data Center). The conditional event sub-process starts when its condition on the process instance becomes true, see Event Sub-Processes in Flower.

Other Event Types

Compensation, cancel, multiple, and multiple parallel events are not executed as in BPMN. A multiple catch event waits and does not go on by itself: a message or signal from outside does not reach it, and the process instance gets a warning comment. An intermediate throw event of these types triggers the Jira Automation rule or webhook like a none throw event, an end event ends its flow like a none end event, and their boundary events never fire. See BPMN Coverage.

Read More

Last updated on