Business Process Modeling Notation (BPMN) shapes

Release version: Australia

Updated March 12, 2026

30 minutes to read

Use the BPMN shapes to generate diagrams for your current business processes and model the future state of the business processes.

BPMN shapes in Enterprise Modeling and Visualization

You can add a shape to the canvas by either selecting the shape or by dragging the shape from the Shapes palette to the canvas.

You can also adjust the size of shapes by selecting a shape and then drag any of its edges or corner handles. Pulling outward increases the shape's dimensions, while dragging inward reduces its size. However, BPMN-Event shapes can’t be resized.

When you drag a BPMN shape from the Shapes palette to the canvas, the shape icon you drag matches the shape's appearance on the canvas. This helps you confirm the correct shape before placing it on the canvas.

BPMN shapes are organized into sub-categories in the Shapes palette: Event, Activity, Gateway, and General. Expand a sub-category to see and add its shapes.

BPMN: General shapes

Table 1. BPMN: General
Shape	Name	Description
	Pool	Represents a swimlane container for a single participant or system in a process. Defines the boundary of a process and organizes the lanes that represent roles or responsibilities within it.
	Lane	Represents a subdivision within a pool, used to assign activities to specific roles, departments, or systems. Organizes responsibilities visually within the parent process boundary.

BPMN-Event shapes

Event shapes represent something that happens during a process. Events are categorized by their position in the process flow — start, intermediate, or end — and by the trigger type that causes or results from the event. Boundary events are attached to an activity shape and fire when a specific condition occurs while the activity is running. BPMN-Event shapes cannot be resized.

Table 2. BPMN-Event
Shape	Name	Description
	Start (Compensation)	Represents a process triggered to perform compensation for a previously completed activity. Used within event subprocesses to initiate rollback or corrective actions when a transaction requires undoing completed work.
	Start (Error)	Represents a process triggered by an error event, used exclusively within event subprocesses. Interrupts the parent process and redirects flow to error-handling logic when the specified error is thrown.
	Start (Escalation)	Represents a process triggered by an escalation signal, used within event subprocesses. Models escalation-driven initiation when an activity or process requires higher-level attention or intervention.
	Start Interrupting Conditional	Represents an interrupting start event that activates when a specified business condition or data state becomes true. Interrupts the parent process and redirects flow to the event subprocess when the condition is met.
	Start Interrupting Message	Represents an interrupting start event activated by an incoming message. Interrupts the parent process and redirects flow to the event subprocess upon receiving the specified message.
	Start Interrupting Signal	Represents an interrupting start event activated by a broadcast signal. Interrupts the parent process and redirects flow to the event subprocess when the specified signal is received.
	Start Interrupting Timer	Represents an interrupting start event activated at a specific time or after a defined interval. Interrupts the parent process and redirects flow to the event subprocess when the timer triggers.
	Start (Multiple)	Represents a start event that activates when any one of several defined trigger types is received. The process begins when any single defined trigger condition is satisfied.
	Start (Non-Interrupting Condition)	Represents a non-interrupting start event activated when a specified condition becomes true. Spawns a concurrent event subprocess without interrupting the parent process flow.
	Start (Non-Interrupting Escalation)	Represents a non-interrupting start event activated by an escalation signal. Spawns a concurrent event subprocess to handle escalation without interrupting the parent process.
	Start (Non-Interrupting Message)	Represents a non-interrupting start event activated by an incoming message. Spawns a concurrent event subprocess without interrupting the parent process flow.
	Start (Non-Interrupting Multiple)	Represents a non-interrupting start event activated by any one of several defined trigger types. Spawns a concurrent event subprocess when any single trigger condition is met.
	Start (Non-Interrupting Parallel Multiple)	Represents a non-interrupting start event activated when all defined trigger types occur simultaneously. Spawns a concurrent event subprocess only when every trigger condition is satisfied.
	Start (Non-Interrupting Signal)	Represents a non-interrupting start event activated by a broadcast signal. Spawns a concurrent event subprocess to handle the signal without interrupting the parent process.
	Start (Non-Interrupting Timer)	Represents a non-interrupting start event activated at a specific time or after a defined interval. Spawns a concurrent event subprocess without interrupting the parent process flow.
	Start (None)	Represents the starting point of a process with no defined trigger. Indicates that the process begins when initiated manually or by an external condition not captured in the model.
	Start (Parallel Multiple)	Represents a start event that initiates only when all defined trigger types occur simultaneously. Every specified trigger must be satisfied before the process begins.
	Intermediate (Catch-Cancel)	Represents an intermediate catch event that captures a cancel event within a transaction subprocess. Redirects process flow to cancellation handling and triggers compensation for completed activities within the transaction.
	Intermediate (Catch-Compensation)	Represents an intermediate catch event that captures a compensation event. Redirects flow to the compensation handler to perform rollback or corrective actions for a previously completed activity.
	Intermediate (Catch-Conditional)	Represents an intermediate catch event that pauses process flow until a specified business condition or data state becomes true. Resumes execution when the defined condition is satisfied.
	Intermediate (Catch-Error)	Represents an intermediate catch event that captures a specific error thrown within the process. Redirects flow to recovery or exception-handling paths when the specified error is received.
	Intermediate (Catch-Escalation)	Represents an intermediate catch event that captures an escalation signal. Redirects process flow to an escalation handler when higher-level attention is required.
	Intermediate (Catch-Message)	Represents an intermediate catch event that pauses process flow until a specific message is received from a participant or system. Resumes execution once the expected message arrives.
	Intermediate (Catch-Multiple)	Represents an intermediate catch event that resumes process flow when any one of several defined trigger types occurs. The first trigger condition to be met is sufficient to continue.
	Intermediate (Catch-Non-Interrupting Condition)	Represents a non-interrupting boundary conditional event that fires when a specified condition is true while an activity is active. Spawns a concurrent flow without interrupting the activity.
	Intermediate (Catch-Non-Interrupting Escalation)	Represents a non-interrupting boundary escalation event that fires while an activity is active. Spawns a concurrent escalation handler without interrupting or canceling the activity.
	Intermediate (Catch-Non-Interrupting Message)	Represents a non-interrupting boundary message event that fires when a message arrives while an activity is active. Spawns a concurrent flow without canceling the activity.
	Intermediate (Catch-Non-Interrupting Multiple)	Represents a non-interrupting boundary event triggered by any defined event type while an activity is active. Spawns a concurrent flow when any single trigger condition is met.
	Intermediate (Catch-Non-Interrupting Parallel Multiple)	Represents a non-interrupting boundary event triggered only when all defined event types occur simultaneously while an activity is active. Spawns a concurrent flow when every condition is satisfied.
	Intermediate (Catch-Non-Interrupting Parallel Multiple)	Represents a non-interrupting boundary event triggered only when all defined event types occur simultaneously while an activity is active. Spawns a concurrent flow when every condition is satisfied.
	Intermediate (Catch-Non-Interrupting Timer)	Represents a non-interrupting boundary timer event that fires at a specific time or interval while an activity is active. Spawns a concurrent flow without interrupting or canceling the activity.
	Intermediate (Catch-Parallel Multiple)	Represents an intermediate catch event that pauses process flow until all defined trigger types occur simultaneously. Resumes execution only when every specified trigger condition is satisfied.
	Intermediate (Catch-Signal)	Represents an intermediate catch event that pauses process flow until a specific broadcast signal is received. Resumes execution when the designated signal arrives from another process or participant.
	Intermediate (Catch-Timer)	Represents an intermediate catch event that pauses process flow until a specific time or interval elapses. Models time-based delays, deadlines, and scheduled waits within a process.
	Intermediate (Link-Catch)	Represents a link catch event that receives process flow from a corresponding link throw event within the same process. Simplifies diagrams by replacing long or crossing sequence flow lines.
	Intermediate (None)	Represents a marker in the process flow with no associated trigger or result. Used to document significant milestones or states within a process that are meaningful to stakeholders but do not affect routing.
	Intermediate (Throw-Compensation)	Represents an intermediate throw event that triggers compensation for one or more previously completed activities. Initiates rollback or corrective actions within transactional process flows.
	Intermediate (Throw-Escalation)	Represents an intermediate throw event that raises an escalation signal to a higher-level handler or event subprocess. Models escalation initiation when standard process flow requires intervention at a broader scope.
	Intermediate (Throw-Link)	Represents a link throw event that transfers process flow to a corresponding link catch event within the same process. Used to simplify complex diagrams by replacing long or crossing sequence flow lines.
	Intermediate (Throw-Message)	Represents an intermediate throw event that sends a message to a participant or external system. Models outbound message transmission as a defined step within the process flow.
	Intermediate (Throw-Multiple)	Represents an intermediate throw event that simultaneously triggers all defined outgoing events. Models multi-event broadcasting from a single point in the process flow.
	Intermediate (Throw-Signal)	Represents an intermediate throw event that broadcasts a signal to one or more listening processes or events. Models signal-based communication within or across process flows.
	Cancellation End	Represents an end event that cancels a transaction subprocess. Triggers compensation for all completed activities within the transaction scope and terminates the transaction flow.
	Compensation End	Represents an end event that triggers compensation for previously completed activities as the final process action. Models rollback as the terminal outcome of a transactional flow.
	End (Link)	Represents an end event that transfers flow to a corresponding link event. Used to simplify diagrams by connecting distant parts of a process without long sequence flow lines.
	End (None)	Represents the completion of a process path with no specific result or outgoing action. Indicates that the current flow terminates without triggering further events, messages, or signals.
	End Error	Represents an end event that terminates a process path by throwing a specific error. The error propagates to an enclosing process or boundary handler for exception-based process termination.
	End Message	Represents an end event that sends a message to a participant or external system as the final action of a process path. Models outbound notification as the terminal outcome of a process flow.
	End Signal	Represents an end event that broadcasts a signal to one or more listening processes as the final process action. Models signal-based notification as the terminal outcome of a process flow.
	End Terminate	Represents an end event that immediately terminates all active process instances and parallel flows. Stops the entire process upon reaching this point, regardless of other paths that may still be active.
	Escalation End	Represents an end event that raises an escalation signal to a higher-level handler. Models escalation as the final outcome of a process flow requiring intervention at a broader scope.
	Multiple End	Represents an end event that simultaneously triggers all defined result events. Models multi-result termination where multiple end behaviors occur from a single endpoint.

BPMN-Activity shapes

Activity shapes represent work performed within a process. Activities are divided into tasks, which are atomic units of work, and sub-processes and call activities, which reference other process flows. You can also apply a marker to any task shape to indicate how the activity executes — for example, whether it loops or runs in parallel.

Table 3. BPMN-Activity: Task
Shape	Name	Description
	Business Rule Task	Represents a task that evaluates a set of business rules to produce a result or decision. Models rule-engine-driven activities such as eligibility checks, policy evaluations, or dynamic calculations.
	Manual Task	Represents a task performed entirely by a human participant without any system or application support. Models unassisted manual activities such as physical document handling or fieldwork that occurs outside the process system.
	Receive Task	Represents a task that waits for a message from an external participant or system before the process can continue. Models inbound message reception as an explicit activity within the process flow.
	Script Task	Represents a task executed automatically by the process engine using a defined script or expression. Models lightweight automation tasks embedded directly in the process flow, such as data transformations or calculations.
	Send Task	Represents a task that sends a message to an external participant or system. Models outbound message transmission as an explicit step where the act of sending is meaningful within the process flow.
	Service Task	Represents a task performed automatically by a system, service, or application without human intervention. Models automated activities such as API calls, system integrations, or background data processing.
	Task	Represents a unit of work within a process performed by a participant or system. Models atomic activities not decomposed further in the current diagram when the task type is unspecified or not relevant to the model.
	User Task	Represents a task performed by a human participant with the assistance of a software application or workflow tool. Models human-in-the-loop activities such as form completion, approvals, and data entry.

Table 4. BPMN-Activity: Sub-Process
Shape	Name	Description
	Business Rule Call Activity	Represents a reusable activity that invokes a globally defined business rule task. Models rule-engine activities maintained centrally and called from multiple processes for consistent policy or rule evaluation.
	Call Activity	Represents a reusable activity that invokes a globally defined task or subprocess. Models process modularity by referencing shared definitions that can be called from multiple parent processes.
	Manual Call Activity	Represents a reusable activity that invokes a globally defined manual task. Models reusable unassisted human activities shared across multiple process definitions.
	Script Call Activity	Represents a reusable activity that invokes a globally defined script task. Models reusable scripted automation activities that are centrally maintained and referenced from multiple processes.
	User Call Activity	Represents a reusable activity that invokes a globally defined user task. Models reusable human-in-the-loop activities shared across multiple processes for consistent task execution.
	Sub-Process	Represents a self-contained group of activities with its own start and end events, embedded within a parent process. Models complex work that is decomposed into a defined internal flow to manage scope and detail.
	Adhoc Sub-Process	Represents a subprocess in which activities are performed in any order, multiple times, or skipped by the participant. Models flexible, unstructured work where participants determine the sequence and frequency dynamically.
	Transaction Sub-Process	Represents a subprocess that groups activities under a transactional boundary, ensuring all-or-nothing behavior. Models transactional integrity where a failure triggers compensation to undo completed activities within the group.

Table 5. BPMN-Activity: Marker
Shape	Name	Description
	Loop - Business Rule Task	Represents a business rule task that evaluates conditions and applies rule-engine logic that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Manual Task	Represents a manual task performed by a human participant without system support that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Receive Task	Represents a receive task that waits for an inbound message before the process continues that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Script Task	Represents a script task executed automatically by the process engine that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Send Task	Represents a send task that transmits a message to a participant or system that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Service Task	Represents a service task executed automatically by a system or application that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - Task	Represents a task representing a generic unit of work with no specified type that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Loop - User Task	Represents a user task performed by a human participant with application support that repeats based on a defined loop condition. The activity executes iteratively until the condition is no longer satisfied.
	Multi Instance Parallel - Business Rule Task	Represents a business rule task that evaluates conditions and applies rule-engine logic that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Manual Task	Represents a manual task performed by a human participant without system support that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Receive Task	Represents a receive task that waits for an inbound message before the process continues that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Script Task	Represents a script task executed automatically by the process engine that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Send Task	Represents a send task that transmits a message to a participant or system that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Service Task	Represents a service task executed automatically by a system or application that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - Task	Represents a task representing a generic unit of work with no specified type that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Parallel - User Task	Represents a user task performed by a human participant with application support that executes multiple instances simultaneously. All instances run in parallel for each item in the defined collection or dataset.
	Multi Instance Sequential - Business Rule Task	Represents a business rule task that evaluates conditions and applies rule-engine logic that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Manual Task	Represents a manual task performed by a human participant without system support that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Receive Task	Represents a receive task that waits for an inbound message before the process continues that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Script Task	Represents a script task executed automatically by the process engine that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Send Task	Represents a send task that transmits a message to a participant or system that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Service Task	Represents a service task executed automatically by a system or application that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - Task	Represents a task representing a generic unit of work with no specified type that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Multi Instance Sequential - User Task	Represents a user task performed by a human participant with application support that executes multiple instances one at a time in sequence. Each instance completes before the next begins, processing items in the collection in order.
	Compensation - Business Rule Task	Represents a business rule task that evaluates conditions and applies rule-engine logic designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Manual Task	Represents a manual task performed by a human participant without system support designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Receive Task	Represents a receive task that waits for an inbound message before the process continues designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Script Task	Represents a script task executed automatically by the process engine designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Send Task	Represents a send task that transmits a message to a participant or system designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Service Task	Represents a service task executed automatically by a system or application designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - Task	Represents a task representing a generic unit of work with no specified type designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Compensation - User Task	Represents a user task performed by a human participant with application support designated as a compensation handler. Executes rollback or corrective actions for the associated activity when a compensation event is triggered.
	Loop & Compensation - Business Rule Task	Represents a business rule task that evaluates conditions and applies rule-engine logic that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Manual Task	Represents a manual task performed by a human participant without system support that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Receive Task	Represents a receive task that waits for an inbound message before the process continues that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Script Task	Represents a script task executed automatically by the process engine that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Send Task	Represents a send task that transmits a message to a participant or system that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Service Task	Represents a service task executed automatically by a system or application that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - Task	Represents a task representing a generic unit of work with no specified type that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.
	Loop & Compensation - User Task	Represents a user task performed by a human participant with application support that both repeats based on a loop condition and serves as a compensation handler. Combines iterative execution with compensation behavior for rollback scenarios.

BPMN-Gateway shapes

Gateway shapes control how the process flow splits and merges. Gateways can be resized on the canvas.

Table 6. BPMN-Gateway: Core
Shape	Name	Description
	Complex	Represents a decision or synchronization point with complex activation conditions not expressible by standard gateway types. Models advanced branching or merging logic that requires custom rules defined in the gateway condition expression.
	Default	Represents the default sequence flow from an exclusive or inclusive gateway when no other defined condition is met. Ensures that the process always has a path to follow when all conditional flows evaluate to false.
	Event	Represents an event-based gateway that routes process flow based on which event occurs first among defined alternatives. Models reactive branching where the next step is determined by incoming events rather than data conditions.
	Event Based (Start)	Represents an instantiating event-based gateway that creates a new process instance when the first of several defined events occurs. Models exclusive event-driven process instantiation without requiring a preceding start event.
	Exclusive	Represents a decision point where exactly one outgoing sequence flow is followed based on evaluated conditions. Models branching logic where only a single path is taken, and merges the first arriving token on convergence.
	Inclusive	Represents a decision point where one or more outgoing sequence flows are followed based on conditions. Models branching logic where multiple paths can be activated simultaneously and synchronizes all active paths on merge.
	Parallel	Represents a forking or synchronization point where all outgoing sequence flows are activated simultaneously. Models parallel execution of multiple process paths and waits for all tokens to arrive before continuing on merge.

Table 7. BPMN-Gateway: Event Based
Shape	Name	Description
	Cancel (End)	Represents a cancel end event that terminates a transaction subprocess by triggering cancellation. All completed activities within the transaction scope are compensated upon reaching this event.
	Cancel Boundary (Interrupting)	Represents an interrupting boundary event that catches a cancel event on a transaction subprocess. Cancels the transaction and initiates compensation for completed activities within it.
	Compensation (End)	Represents a compensation end event that triggers rollback for previously completed activities as the final process action. Models corrective undoing as the terminal outcome of a transactional flow.
	Compensation (Interrupting)	Represents an interrupting boundary compensation event on an activity. Catches a compensation trigger, cancels the activity, and executes the designated compensation handler for rollback.
	Compensation (Throwing)	Represents an intermediate throw event that broadcasts a compensation signal to trigger rollback for one or more completed activities. Initiates corrective or undo actions within transactional process flows.
	Compensation Boundary (Interrupting)	Represents a boundary compensation event attached to an activity. Catches a compensation event and executes the rollback or corrective handler designated for that activity.
	Conditional	Represents a conditional start event that activates when a specified business condition or data state becomes true. Models condition-driven process initiation evaluated against data changes or business rules.
	Conditional (Catching)	Represents an intermediate conditional catch event that pauses process flow until a specified condition becomes true. Resumes execution when the defined business condition or data state is satisfied.
	Conditional (Interrupting)	Represents an interrupting boundary conditional event that triggers when a specified condition is true while an activity is active. Interrupts the activity and redirects flow to the boundary event path.
	Conditional (Non-Interrupting)	Represents a non-interrupting boundary conditional event that triggers when a specified condition is met while an activity is active. Spawns a concurrent flow without interrupting or canceling the activity.
	Conditional Boundary (Interrupting)	Represents an interrupting boundary event that fires when a condition is met while the attached activity is active. Cancels the activity and redirects flow to the defined boundary handling path.
	Conditional Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that fires when a condition is met while the attached activity is active. Spawns a concurrent flow without interrupting or canceling the activity.
	End	Represents a none end event that terminates a process path with no specific result. Indicates that the current flow ends without triggering further events, messages, or signals.
	Error (End)	Represents an error end event that terminates a process path by throwing a specific error. The error propagates to an enclosing process or boundary handler for exception-based process termination.
	Error (Interrupting)	Represents an interrupting boundary error event that fires when an error is thrown by the attached activity. Cancels the activity and redirects flow to the designated error-handling path.
	Error Boundary (Interrupting)	Represents an interrupting boundary event that catches a specific error thrown by the attached activity or subprocess. Cancels the activity and routes flow to the error handler. Error boundary events are always interrupting.
	Escalation (End)	Represents an escalation end event that raises an escalation signal as the final action of a process path. Notifies a higher-level handler that intervention is required beyond the current process scope.
	Escalation (Interrupting)	Represents an interrupting boundary escalation event on an activity. Catches an escalation signal, cancels the activity, and redirects flow to the escalation-handling path.
	Escalation (Non-Interrupting)	Represents a non-interrupting boundary escalation event on an activity. Catches an escalation signal and spawns a concurrent escalation handler without interrupting or canceling the activity.
	Escalation (Throwing)	Represents an intermediate throw event that raises an escalation signal to a higher-level handler or event subprocess. Models escalation initiation when standard process flow requires broader-scope attention.
	Escalation Boundary (Interrupting)	Represents an interrupting boundary event that catches an escalation signal while the attached activity is active. Cancels the activity and redirects flow to the escalation-handling path.
	Escalation Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that catches an escalation signal while the attached activity is active. Spawns a concurrent escalation flow without interrupting or canceling the activity.
	Intermediate	Represents a none intermediate event that marks a significant milestone or state in the process flow with no associated trigger or result. Used to document checkpoints meaningful to stakeholders without affecting routing.
	Link (Catching)	Represents a link catch event that receives process flow from a corresponding link throw event within the same process. Simplifies diagrams by replacing long or crossing sequence flow lines.
	Link (Throwing)	Represents a link throw event that transfers process flow to a corresponding link catch event within the same process. Used to replace long or crossing sequence flow lines.
	Message	Represents a message start event that activates when a specific message is received from a participant or system. Models message-driven process initiation such as a customer request or system notification.
	Message (Catching)	Represents an intermediate message catch event that pauses process flow until a specific message is received. Resumes the flow once the expected message arrives from the designated participant or system.
	Message (End)	Represents a message end event that sends a message to a participant or system as the final action of a process path. Models outbound notification as the terminal outcome of a process flow.
	Message (Interrupting)	Represents an interrupting boundary message event on an activity. Catches an incoming message, cancels the activity, and redirects process flow to the boundary event path.
	Message (Non-Interrupting)	Represents a non-interrupting boundary message event on an activity. Catches an incoming message and spawns a concurrent flow without interrupting or canceling the activity.
	Message (Throwing)	Represents an intermediate message throw event that sends a message to an external participant or system. Models outbound message transmission as a defined step within the process flow.
	Message Boundary (Interrupting)	Represents an interrupting boundary event that catches an incoming message while the attached activity is active. Cancels the activity and redirects flow to the message-handling path.
	Message Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that catches an incoming message while the attached activity is active. Spawns a concurrent flow without canceling the activity.
	Multiple	Represents a multiple start event that activates when any one of several defined event types occurs. The process begins when any single defined trigger condition is satisfied.
	Multiple (Catching)	Represents an intermediate catch event that resumes when any one of several defined event types occurs. Models multi-trigger synchronization where the first satisfied condition continues the flow.
	Multiple (End)	Represents a multiple end event that simultaneously triggers all defined result events. Models multi-result termination where all defined behaviors occur from a single endpoint.
	Multiple (Interrupting)	Represents an interrupting boundary multiple event on an activity. Triggers when any defined event type occurs, cancels the activity, and redirects flow to the boundary path.
	Multiple (Non-Interrupting)	Represents a non-interrupting boundary multiple event on an activity. Triggers when any defined event type occurs and spawns a concurrent flow without interrupting or canceling the activity.
	Multiple (Start)	Represents a multiple start event that initiates the process when any one of several defined trigger types is received. Use when the process can begin from more than one type of initiating event.
	Multiple (Throwing)	Represents an intermediate throw event that simultaneously broadcasts all defined outgoing event types. Models multi-event notification from a single point in the process flow.
	Multiple Boundary (Interrupting)	Represents an interrupting boundary event triggered by any one of several defined event types while the attached activity is active. Cancels the activity and redirects flow when any trigger condition is met.
	Multiple Boundary (Non-Interrupting)	Represents a non-interrupting boundary event triggered by any defined event type while the attached activity is active. Spawns a concurrent flow without canceling the activity.
	Parallel Multiple	Represents a parallel multiple start event that activates only when all defined trigger types occur simultaneously. All specified triggers must be satisfied before the process begins.
	Parallel Multiple (Catching)	Represents an intermediate parallel multiple catch event that resumes only when all defined trigger types occur simultaneously. All trigger conditions must be met before the flow continues.
	Parallel Multiple (Interrupting)	Represents an interrupting boundary parallel multiple event on an activity. Triggers only when all defined event types occur together, cancels the activity, and redirects flow.
	Parallel Multiple (Non-Interrupting)	Represents a non-interrupting boundary parallel multiple event on an activity. Triggers when all defined event types occur simultaneously and spawns a concurrent flow without interrupting the activity.
	Parallel Multiple Boundary (Interrupting)	Represents an interrupting boundary event that activates when all defined event types occur simultaneously while the attached activity is active. Cancels the activity and redirects flow when every condition is met.
	Parallel Multiple Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that activates when all defined event types occur simultaneously while the attached activity is active. Spawns a concurrent flow without canceling the activity.
	Signal	Represents a signal start event activated by a broadcast signal from another process or participant. Models signal-driven process initiation for cross-process communication where multiple processes may respond.
	Signal (Catching)	Represents an intermediate signal catch event that pauses process flow until a specific broadcast signal is received. Resumes the flow once the designated signal arrives from another process or participant.
	Signal (End)	Represents a signal end event that broadcasts a signal to listening processes as the final action of a process path. Models signal-based notification as the terminal outcome of a process flow.
	Signal (Interrupting)	Represents an interrupting boundary signal event on an activity. Catches a broadcast signal, cancels the activity, and redirects process flow to the signal-handling path.
	Signal (Non-Interrupting)	Represents a non-interrupting boundary signal event on an activity. Catches a broadcast signal and spawns a concurrent flow without interrupting or canceling the activity.
	Signal (Throwing)	Represents an intermediate signal throw event that broadcasts a signal to one or more listening processes or events. Models signal-based communication within or across process flows.
	Signal Boundary (Interrupting)	Represents an interrupting boundary event that catches a broadcast signal while the attached activity is active. Cancels the activity and redirects flow to the signal-handling path.
	Signal Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that catches a broadcast signal while the attached activity is active. Spawns a concurrent flow without canceling the activity.
	Start	Represents the starting point of a process with no defined trigger. Indicates that the process begins when initiated manually or by an external condition not captured in the model.
	Terminate	Represents an end event that immediately terminates all active process instances and parallel flows. Stops the entire process upon reaching this point, regardless of other paths that may still be active.
	Timer	Represents a timer start event that activates at a specific time or after a defined interval. Models time-driven process initiation such as scheduled batch jobs, periodic workflows, or deadline-based triggers.
	Timer (Catching)	Represents an intermediate timer catch event that pauses process flow until a specific time or interval elapses. Models time-based delays, deadlines, and scheduled waits within a process flow.
	Timer (Interrupting)	Represents an interrupting boundary timer event on an activity. Triggers at a specific time or interval while the activity is active, cancels it, and redirects flow to the boundary event path.
	Timer (Non-Interrupting)	Represents a non-interrupting boundary timer event on an activity. Triggers at a specific time or interval while the activity is active and spawns a concurrent flow without interrupting the activity.
	Timer Boundary (Interrupting)	Represents an interrupting boundary event that fires at a specific time or after a defined interval while the attached activity is active. Cancels the activity and redirects flow to the timer-handling path.
	Timer Boundary (Non-Interrupting)	Represents a non-interrupting boundary event that fires at a specific time or after a defined interval while the attached activity is active. Spawns a concurrent flow without canceling the activity.