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

BPMN Signal Events

Next releaseThis comes with the next release of Flower BPM, for Jira Cloud (Forge) and Jira Data Center. Until then, the released version works as before.

In short: A signal event is a circle with a triangle. A white triangle waits for a signal, a black one sends one. A signal is news for everyone who listens: the price list has changed, the release is approved, the office is closed. In Flower every process instance that waits for a signal of that name gets it, at the same time. A person, a Jira Automation rule, another system, or another process sends it.

🛠️

Quick start: model an intermediate signal catch event, select a signal named Price list changed, and publish. Start two process instances. When both wait there, write the comment @FlowerBPM signal Price list changed on any work item. Both processes go on.

Symbols

SymbolElementMeaning
BPMN symbol: signal start eventSignal start eventThe process starts when the signal comes
BPMN symbol: intermediate signal catch eventIntermediate signal event (catch)The process waits here until the signal comes
BPMN symbol: interrupting signal boundary eventSignal boundary event, interruptingWhile the activity runs, the signal comes: the activity ends and the path of the event is taken
BPMN symbol: non-interrupting signal boundary eventSignal boundary event, non-interruptingThe activity stays open and the path of the event starts in addition. Dashed border
BPMN symbol: signal event sub-processSignal event sub-process, interruptingWhile the process runs, the signal comes: the process stops and the event sub-process takes over
BPMN symbol: non-interrupting signal event sub-processSignal event sub-process, non-interruptingThe event sub-process runs beside the process. Dashed border
BPMN symbol: intermediate signal throw eventIntermediate signal event (throw)The process sends a signal and goes on
BPMN symbol: signal end eventSignal end eventThe path ends and sends a signal

Signal or Message

A signal and a message both come from outside and both move a waiting process on. The difference is who gets them.

SignalMessage
Who gets itEvery process instance that waits for itOne process instance
How it is addressedOnly by its nameBy its name and the key of the process instance (or one of its work items)
Typical useNews for many: Price list changed, Release approved, Year-end closing startedAn answer for one case: Payment received, Supplier confirmed
Nobody waitsNothing happensThe message is dropped with a warning comment

Rule of thumb: if the sender knows the case, send a message. If the sender only knows that something happened, send a signal.

What Waits for a Signal

These elements wait for a signal in Flower:

ElementWhat happens when the signal comes
Intermediate signal catch eventThe process goes on after it
Signal boundary event, interruptingFlower closes the work item of the activity and takes the path of the event
Signal boundary event, non-interruptingThe work item stays open, the path of the event starts in addition
Signal start eventThe process instance is created and waits at the start. The first task starts when the signal comes
Signal event sub-process, interrupting or non-interruptingIt starts, like the other event sub-processes
Signal catch event behind an event-based gatewayIt takes the path when its signal comes first. A timer, a conditional event, or a message behind the same gateway can win as well; the events that do not win are discarded, see Event-Based Gateways

Each of them waits for a signal of one name: the name of the BPMN signal that the element references. Select or create the signal in the properties panel of the element and give it a name, for example Price list changed. Upper and lower case do not matter: price list changed reaches it too.

While an element waits, the process instance gets the comment Waiting for the signal Price list changed at …. It is a note, not a warning.

Flower also marks the process instance: the property flower.waitsForSignal holds the names it waits for. In JQL it is flowerSignal, with the name normalized: upper case, without accents and apostrophes, -, _ and several spaces as one space (Won’t Do is WONT DO):

flowerSignal = "PRICE LIST CHANGED"

This search lists the process instances that a signal of this name would reach now.

Send a Signal

There are four ways to send a signal. None of them needs the key of a process instance: the name is enough.

WayWho uses itHosts
A comment with a line @FlowerBPM signal <name>A person, a Jira Automation rule that acts as a person, any system with the Jira REST APICloud and Data Center
The Jira Automation action Flower: Send signalA Jira Automation ruleCloud
POST /rest/flower/latest/service/processSignalAnother system, a Send web request of Jira Automation, a scriptData Center
A signal throw event or signal end event of a processAnother processCloud and Data Center

With a Comment

Write a comment on any work item. It does not have to belong to a process: a work item in a team space, a release ticket, or a process instance all work. A line that starts with @FlowerBPM signal sends a signal. The rest of that line is the name of the signal:

@FlowerBPM signal Price list changed list: 2027 valid from: 2027-01-01 The new prices apply to all open offers.

This comment sends the signal Price list changed with the data:

{ "list": "2027", "valid from": "2027-01-01", "text": "The new prices apply to all open offers." }

The rules:

  • The word after @FlowerBPM is the command. signal sends a signal. message, or no word at all, sends a message to the process of the work item. So @FlowerBPM Payment received stays a message.
  • The lines directly after it in the form key: value become the data.
  • All other text of the comment becomes text in the data.
  • The values are text. A condition such as > 1000 still compares them as numbers.
  • @FlowerBPM must start a line. Upper and lower case do not matter, @Flower BPM works too, also when the editor turns it into a mention.

Flower answers on the commented work item:

  • Signal Price list changed sent. To FLOW-1, FLOW-2. with the process instances it reached, or
  • Signal Price list changed sent. No process instance waits for it.

A person writes this comment by hand. Any system writes it with the Jira REST API. A comment that a Jira Automation rule writes (action Add comment) counts when the rule acts as a person who can edit (its actor). On Cloud the default actor Automation for Jira is an app account, and Flower ignores comments of apps: there the rule uses the action Flower: Send signal below, or acts as a person.

With Jira Automation

How rules and processes work together in both directions, on Forge and Data Center: Flower BPM and Jira Automation.

On Cloud, Flower adds the action Flower: Send signal to Jira Automation. Its inputs:

InputValue
Name of the signalThe name of the signal, for example Price list changed
DataOptional: text or JSON that the processes can read

The action needs no work item. A scheduled rule can send a signal every Monday, for example:

The rule builder of Jira Automation: the trigger Scheduled, every Monday, then the action Flower: Send signal with the inputs Name of the signal and Data

The first time someone adds an action of Flower to a rule, the rule author connects the app once for the site.

With the REST API (Data Center)

On Data Center, another system sends a signal with a POST request:

POST /rest/flower/latest/service/processSignal Content-Type: application/json { "name": "Price list changed", "data": { "list": "2027" } }
  • name is the name of the signal.
  • data is optional and can be any JSON.

The answers:

StatusMeaning
202 {"queued": true}The signal is accepted and will be delivered
400name is missing
403The caller is not logged in

A comment with @FlowerBPM signal works on Data Center too.

From Another Process

A signal intermediate throw event or a signal end event sends the signal of its name to every process instance that waits for it. The throw event also triggers its Jira Automation rule, or calls its webhook URL (Connect, Data Center), as every throw event does; the end event does that only when it has a webhook URL or the request type Jira Automation. See Trigger Jira Automation. Inside its own process instance, BPMN delivers the signal directly, without a detour.

This is how one process tells many others: a release process ends with the signal end event Release approved, and every deployment process that waits for it goes on.

Who Is Reached

SenderReaches
A person: a comment, the action of a rule (its actor), the REST APIThe waiting process instances that this person can edit
A signal throw or end event of a processAll waiting process instances
  • The writer of a comment must also be able to edit the work item they comment on. Otherwise Flower writes a warning comment and sends nothing.
  • One signal reaches at most 1000 process instances, the oldest first.
  • A process instance that does not wait for the signal any more when its turn comes is skipped silently.

One Inbox for Messages and Signals

For admins and integrators: every way in ends in the same entry point of Flower, the inbox. A comment, the Jira Automation actions, the Data Center REST API, and a signal throw or end event all hand their message or signal to it.

The inbox finds the receiving process instances: those that wait for the signal and that the sender can edit (a signal throw or end event of a process reaches all of them; a sender whose account is not known, for example a rule without an actor, reaches none). Each way in checks its sender before (a comment is handled once). Then the inbox gives every receiving process instance its own delivery. The deliveries of one process instance run one after the other, so two signals never change the same process instance at the same moment. The same entry point is prepared for further commands.

Use the Data in Conditions

Flower keeps the data of the last delivered signal of each name at the process instance, in flower.signalData, up to 2000 characters (longer data is cut, with a warning comment). JSON text from the Jira Automation action becomes an object. A gateway after the catch event decides with it:

Gateway flowCondition
New price list${pi.properties.flower.signalData['Price list changed'].list == '2027'}
Release 5${pi.properties.flower.signalData['Release approved'].version == '5.0'}

The key is the name of the signal as the sender wrote it. The data is there already in the run that delivers the signal, so a gateway directly after the catch event sees it. See Expressions.

What Flower Writes

WhenComment
An element starts to waitWaiting for the signal … at … on the process instance (a note)
The signal is deliveredSignal … received on the process instance, with the elements that got it
A comment sent the signalSignal … sent on the commented work item, with the process instances it reached, or No process instance waits for it
The writer of the comment cannot edit the work itemA warning comment on the commented work item

Every delivered signal is listed in the property flower of the process instance:

PropertyContains
flower.messagesThe handled messages and signals in the order they arrived (the last 50). A signal has kind: 'signal', plus name, withData (the data itself is in flower.signalData), at, by, via (comment, automation, rest or throw), delivered, and nodes (the elements that got it)
flower.signalData['<name>']The data of the last delivered signal of that name
flower.waitsForSignalThe names of the signals the process instance waits for now (JQL flowerSignal)

Read it with the Jira REST API, GET /rest/api/3/issue/{key}/properties/flower, or in expressions as pi.properties.flower.

Edge Cases

  • Nobody waits: the signal reaches no process instance. There is no warning, and the signal is not kept for later. A process instance that reaches its catch event afterwards waits for the next signal.
  • A signal does not create process instances. The process instance with a signal start event is created as usual, and then it waits at its start for the signal.
  • A comment is handled once. Changing it later sends nothing. Write a new comment instead.
  • Comments of the app itself are ignored.
  • Restricted comments (Cloud): a comment that is visible only to a group or a role is not seen by the app.
  • A name that starts with “signal” or “message”: write the command word in front of it. @FlowerBPM message Signal received sends the message Signal received.
  • A signal without a name: the validator warns: … has a signal without a name: select or create a signal with a name. Signals are matched by their name.

Common Mistakes

  • @FlowerBPM Price list changed without signal. That is a message to the process of the commented work item, not a signal.
  • A signal where a message is meant. A signal reaches every waiting process instance. To answer one case, send a message.
  • The signal is sent before the processes wait. It reaches nobody. Let the processes wait first, or use a conditional event on a field that stays set.
  • The sender cannot edit the process instances. A signal from a person reaches only what this person can edit. Let a Jira Automation rule with a suitable actor send it, or a signal throw event of a process.

Read More

Frequently Asked Questions

What is a signal event in BPMN?

An event that sends or receives a signal. A signal has no receiver: everyone who listens gets it. It is drawn as a circle with a triangle: white when it waits, black when it sends.

What is the difference between a signal and a message in BPMN?

A message goes from one sender to one receiver. A signal is broadcast: every process instance that waits for it gets it. In Flower a message needs the key of the process instance, a signal only its name.

How do I continue many Jira processes at once?

Let them wait at a signal catch event with the same signal name. Then write a comment @FlowerBPM signal <name> on any work item, use the Jira Automation action Flower: Send signal, or end another process with a signal end event.

Can I pass data with the signal?

Yes. In a comment, the lines key: value after the @FlowerBPM signal line become the data. A gateway reads it as pi.properties.flower.signalData['<name>'].

Which process instances does a signal reach?

Every open process instance that waits for a signal of that name, at most 1000. A signal from a person reaches only the process instances this person can edit.

Last updated on