Overview
Operators are built-in logic nodes that control the flow of an automation — branching on conditions, iterating over lists, pausing execution, and grouping steps for shared error handling — without requiring any custom code.


Operators appear in the Logic tools section of the node picker. They work on the automation's internal data (data pills from earlier steps, variables, and literal values) and determine which path the run takes next. Each operator is configured through a visual editor; no scripting is needed.
Operators are the primary way to express decision logic and control flow in Unify Automations. Well-placed operators replace entire classes of custom code and make an automation's intent visible on the canvas to any reviewer.
Note: Operators are distinct from app action steps. An app action step calls an external service; an operator acts on the automation's own data and execution path. You can combine them freely in any sequence.
Available Operators
Operator | What it does |
|---|---|
Condition | The Condition (If / Else) node evaluates a test. When true, the run follows the If / True path. When false, the conditional branch is skipped and execution continues to the next node. |
Branch | Routes the run down every path whose condition is true — matching paths run in parallel. If no condition matches, the run continues to the step after the Branch. Use it for several distinct outcomes; make the conditions mutually exclusive if only one path should run. |
Loop | Repeats the steps inside the loop body. Choose one of three types: For each loop (once for each item in a list, such as rows, tickets, or array items returned by an earlier step), For loop (a counter from a start value to a limit by a step increment), or While loop (repeats as long as a condition is true, for example in a polling pattern). For and While loops are capped at 50,000 iterations. |
Continue | Skips the remaining steps in the current loop iteration and moves to the next one. Use inside a Loop to bypass items that do not meet a criterion without stopping the whole loop. |
Break | Exits the loop immediately, skipping all remaining iterations. Use when a condition is met that means further iteration is unnecessary. |
Delay | Pauses the automation run for a set duration (Set delay duration) or until a specific date and time (Schedule delay until) before continuing to the next step. Use to rate-limit downstream API calls, wait for an external process, or space out notifications over time. |
Stop | Ends the current run at this point. In a sub-automation, it ends only the child run, and the parent continues. |
Scope | Groups steps together so they share error handling and can be retried or managed as a block. Use to isolate a risky sequence — an external call, a write, a parse — and define a consistent failure response for the whole group. |
How to Add an Operator
In the flow builder, click the dashed + add button below the last step, or click the add affordance between two existing steps.
The node picker opens. Navigate to the Logic tools section, or search by operator name.
Select the operator you want. It is added to the canvas and connected to the step above it.
Select the new operator node to open its properties panel. Configure its conditions, iteration source, duration, or grouping as required — each operator's settings are described on its own page.
Note: The add button only appears when you have edit access to the automation. A read-only automation shows the canvas but no add control.
Notes
Keep the following in mind when using operators in an automation:
Execution behavior depends on the operator. Loop iterations run one at a time and in order, while Delay is asynchronous: longer waits are persisted and scheduled rather than holding a worker.
Use the Scope operator to group related nodes and apply shared error handling, rather than configuring error handling on each individual node.
Nested operators work (for example, a Loop inside a Branch path), but deeply nested structures are harder to debug; keep nesting shallow when possible.
After adding a Branch or Loop, run a test with data that exercises each path to confirm conditions resolve as expected before deploying.
Operators appear in the same node picker as action nodes; search by name (Loop, Branch, Delay, Scope) to find them quickly.