# Events in BPMN

> Events represent something that happens during a process. Events can start, interrupt, delay, or end the process flow. In BPMN, each event is defined by its type (start, intermediate, end) and trigger (e.g., message, timer, error). This page describes how events should be modeled in Maestro diagrams, independent of execution support.

Events represent something that happens during a process. Events can start, interrupt, delay, or end the process flow. In BPMN, each event is defined by its type (start, intermediate, end) and trigger (e.g., message, timer, error). This page describes how events should be modeled in Maestro diagrams, independent of execution support.

## Modeling recommendations

* Prefer descriptive labeling on all events to indicate business meaning (e.g., `Timeout after 2 days` instead of `Timer`).
* Use signal events only for loose coordination; avoid using them to enforce logic.
* For large diagrams, use link events to avoid clutter caused by long flows.
* Do not overuse intermediate events. Focus on clarity over completeness.

## Start events

A start event defines how a process begins. A diagram must include at least one start event.

| Event type | Icon | Meaning |
| --- | --- | --- |
| None |  | Used for manual starts or when the trigger is defined outside the BPMN model. |
| Message | ![message start event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-message-start-event-587099-3ed48209.webp) | Indicates the process is triggered by an incoming message. Often used in called processes. |
| Timer | ![timer star events](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-timer-star-events-587103-72c08ce0.webp) | Indicates the process starts at a specific time or after a delay. Useful for scheduled operations. |

You can model multiple start events in the same process to support different entry points.

When you have multiple start events and you want to do a Debug, open the context menu for the start event you want to test, then select **Test**.

  ![start event test](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-start-event-test-604315-23683af1.webp)

When you deploy a process, you can set a **default entry point** (a start event). Orchestrator uses this start event when you start the process without explicitly specifying one. You can still run or debug from any other start event by selecting it at run time.

  ![entry point orchestrator](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-entry-point-orchestrator-604311-cc13d614.webp)

:::note
A process in Maestro must include at least one start event. You can model multiple start events within the same process to support different entry points (for example FHTTP/API), scheduled, or manual triggers. Use sub-processes to model additional entry points.
:::

For more details about the BPMN elements supported in Maestro, see [BPMN support](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/bpmn-support).

## Intermediate events

Intermediate events model things that happen between the start and end of a process. They can delay the flow, wait for an input, or signal something to other elements.

| Event type | Icon | Usage |
| --- | --- | --- |
| Message (Catching) | ![Message catching intermediate event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-intermediate-message-catching-587113-67d16ad2.webp) | Waits for a message to continue. Placed inline or on a boundary. |
| Timer | ![intermediate timer event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-intermediate-timer-event-587117-dd92a9b4.webp) | Delays flow until a timestamp or duration. Commonly used for timeouts. |
| Signal (Throw/Catch) | ![Signal throw/catch intermediate event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-intermediate-signal-throw-catch-587121-66fdacea.webp) | Broadcasts or waits for a signal. Use to loosely couple process fragments. |
| Link (Throw/Catch) | ![Link catch/throw intermediate event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-intermediate-link-catch-throw-587125-87fc920c.webp) | Used as off-page connectors. Improves readability in large diagrams. |
| Escalation (Throw/Catch) | ![Escalation throw/catch intermediate event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-intermediate-escalation-throw-catch-587129-c430bb40.webp) | Indicates a business-level escalation. Typically attached to boundary events. |
| Error | ![Error boundary event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-error-boudary-event-587133-73c693ac.webp) | Represents an exception. Must be caught by an error boundary event on a task or sub-process. |

:::warning
In modeling, intermediate events should be used to clarify dependencies or timing logic. The actual behavior may depend on runtime support.
:::

For more details about the BPMN elements supported in Maestro, see [BPMN support](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/bpmn-support).

## Boundary events

Boundary events are attached to tasks or sub-processes to model interruptions or timeouts.

| Event type | Icon | Behavior |
| --- | --- | --- |
| Interrupting timer | ![timer boundary event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-timer-boundary-event-587139-5ac2e27f.webp) | When the timer fires, cancel the attached task/sub-process and follow the boundary flow. Use for timeouts, SLAs, or deadlines. If you need the activity to continue, use a **non-interrupting** timer boundary event. |
| Interrupting error | ![error boundary event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-error-boudary-event-587133-73c693ac.webp) | Catches an Error thrown by the attached activity or its inner work, cancels that activity, and routes to the boundary flow. In BPMN, error boundary events are always **interrupting**. Common with Call Activities to handle errors from a called process. |
| Escalation | ![escalation boundary event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-escalation-boundary-event-587143-294f4aca.webp) | Catches an Escalation from within the attached activity. If marked **interrupting**, it cancels the activity; if **non-interrupting**, it starts the boundary flow in parallel while the activity continues. Use to notify or raise attention without treating it as a failure. |

:::warning
Use boundary events to represent expected exceptions or alternate flows. Place them visually on the edge of the task they monitor.
:::

For more details about the BPMN elements supported in Maestro, see [BPMN support](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/bpmn-support).

## End events

End events indicate how a path terminates. Each path in a diagram should end with one

| Event type | Icon | Meaning |
| --- | --- | --- |
| None |  | Marks the end of a path with no specific result. If other paths are still active, the process instance continues. |
| Message | ![message end event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-message-end-event-587148-0b448988.webp) | Sends a message to an external participant or system when the path ends. Often used to notify other processes or trigger downstream workflows. |
| Error | ![error end event](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-error-end-event-587152-e13f4d39.webp) | 	Throws an error when the path ends. If the process runs as a subprocess, the error propagates to the parent process and can be caught by an error boundary event. |
| Terminate | ![Terminate end event icon](https://dev-assets.cms.uipath.com/assets/images/maestro/maestro-terminate-end-event-587156-a220fc92.webp) | Immediately ends the entire process instance, canceling all active paths. |

:::warning
Use end events consistently to signal completion or failure. Avoid leaving paths open.
:::

For more details about the BPMN elements supported in Maestro, see [BPMN support](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/bpmn-support).

## Special event types

The following event types can appear as **intermediate**, **boundary**, or **end events**, depending on usage. These events typically model waiting, signaling, exceptions, or off-page navigation. They are supported for modeling clarity in Maestro.

| Event types | Description | Typical use | Execution in Maestro |
| --- | --- | --- | --- |
| Timer | Waits for a specific time, duration, or cycle | Deadlines, delays, timeouts | ✅ |
| Signal | Broadcasts or receives a named signal across process boundaries | Loose-coupled notification | ❌ |
| Error | Interrupts the current activity or path due to an exception | Business errors, validation failures | ✅ |
| Link | Connects different parts of a process, often across pages | Improves readability, avoids long arrows | ❌ |

### Modeling guidelines

* **Timer Events**: Use as intermediate or boundary events to represent time-based control (e.g., `Wait 2 days`, `Escalate after timeout`).
* **Signal Events**: Use to coordinate across disconnected paths or sub-processes. Avoid relying on signal order or delivery timing.
* **Error Events**: Use on boundary events to redirect the flow on failure. Also valid as end events when explicitly terminating with an error.
* **Link Events**: Always pair a throw and a catch. Useful for breaking up complex diagrams into readable sections.
  :::warning
  All of these events are supported in Maestro for both modeling and execution, except where noted. Label each clearly to reflect its business intent.
  :::

For more details about the BPMN elements supported in Maestro, see [BPMN support](https://docs.uipath.com/maestro/automation-cloud/latest/user-guide/bpmn-support).