Continue Node
Skip the remainder of the current loop iteration and advance immediately to the next item.
LoopContinueSignal flag in the execution memory. The enclosing Loop node detects this signal, discards the remainder of the current iteration's body subgraph, increments the index, and fires the body port again for the next item. The Continue node is the complementary sibling to the Break node — both control loop flow but Break exits the loop while Continue advances to the next iteration.
Key Capabilities
- Skips remaining body nodes for the current iteration without error, advancing cleanly to the next array element.
- The loop continues to completion — only the current iteration is skipped, not the loop itself.
- Requires no configuration — place the node in the body subgraph and connect an incoming wire from the appropriate branch of an If Condition.
- Variables set in partial iterations (before the Continue fires) are preserved and visible in subsequent iterations and after the loop completes.
- Works seamlessly alongside Break — a loop body can contain both a Break path and a Continue path, each triggered by different conditions.
- Ideal for implementing filter logic inside a loop — process only items that meet a criterion, skip all others.
Business Benefits
Real-world data collections are rarely perfectly clean. Arrays contain null entries, records in invalid states, items that have already been processed in a previous run, or items that simply don't meet the criteria for the current operation. Without the Continue node, handling these cases requires wrapping the entire body subgraph in an If Condition — every node in the body becomes part of the "if this item is valid" branch. This creates deeply nested, hard-to-read workflow structures.
The Continue node provides a clean, flat alternative. Add a single If Condition at the start of the loop body — if the item should be skipped, route to Continue; if it should be processed, proceed normally. The remaining body nodes are written at the top level, not nested inside a conditional branch. The result is a workflow that reads more like a clear business rule: "for each item, if it doesn't qualify, skip it; otherwise process it."
The Continue node is also valuable for resilience. In long-running batch operations, individual items may fail API calls or validation checks for transient reasons. Rather than aborting the entire loop with a Break, a Continue can log the failure and advance to the next item — maximising the proportion of the batch that is successfully processed.
Use Cases
Skip Items That Don't Meet a Filter Condition
A reporting workflow loops over all customers to generate monthly statements. Customers with no transactions in the period are skipped via Continue — no statement is generated and no notification is sent. Only customers with activity have statements created and emailed.
Skip Already-Processed Records
A data migration loop processes records from a legacy system. Each record is checked against a processed-IDs list. If the record ID is already in the list (indicating it was processed in a previous run), the Continue node skips it. Only new records are migrated, making the loop idempotent and safe to re-run.
Skip Null or Invalid Items
An integration workflow receives an array from an external API that may contain null entries or malformed objects. A validation check at the top of the loop body routes null or invalid items to Continue, ensuring downstream API calls only receive well-formed data.
Skip Items That Throw Errors (Resilient Batch)
A bulk enrichment workflow calls an external data enrichment service for each record. If the service returns an error for a specific record (e.g., a rate limit hit on a specific lookup), the error is logged and a Continue skips to the next record. The batch continues processing; a post-loop report lists which records need a retry pass.
In This Guide
Configuration
No properties required. This page covers placement requirements and the LoopContinueSignal mechanism in detail.
Input & Output
The continue output port, how the signal is processed by the Loop node, and data state after a skipped iteration.
Examples
Configurations for filter-by-condition, idempotent processing, null skipping, and resilient batch operations.