Run Later

Overview

Run later schedules a portion of your flow to execute at a future time, either as a one-time delayed execution or as a recurring schedule. The flow continues immediately via the Pass exit, while the scheduled portion runs independently at the specified time.

IMPORTANT: Use caution when calling this stage multiple times and setting the Restart Timer flag to False as this will create multiple running timers per flow trigger in parallel.
Run later will run even after a break if there is information inside and the flow is enabled. Scheduled executions persist across flow restarts.

Configuration

Required Fields

Field	Description	Example
Timer ID	Unique identifier for this scheduled execution	orderReminder_{{UserTime}}, dailyReport
Delay of time (MINS)	How long to wait before executing (in minutes)	5 (5 min), 1440 (24 hours), {{UserDelayedMinutes}}
Stages to Execute	Connect stages to the Iterate exit - these run at the scheduled time	Connected to Iterate exit

Optional Fields

Restart Timer: Cancel previous schedules with same Timer ID before creating new one. Enable this for recurring schedules to prevent duplicates.
On The Minute: Execute exactly at the start of the target minute (e.g., 14:23:00) instead of including seconds (e.g., 14:23:47).

Note about "Restart timer" label: This field cancels and replaces any existing schedule with the same Timer ID. Use this to update recurring schedules or cancel obsolete timers.

Exit Points

Exit	When
Pass (green)	Executes immediately after schedule is created - main flow continues without waiting
Iterate (blue)	Executes at the scheduled future time in a new flow instance

How It Works

When executed, the stage:

Captures current state - Takes a snapshot of all flow variables at this moment
Creates schedule - Saves the schedule to the database with the delay time and variable snapshot
Routes to Pass immediately - Main flow continues without waiting
Executes at scheduled time - A new flow instance runs the Iterate path with the captured variables

Time Calculation

The Delay field uses this logic to determine when to execute:

Value Type	Interpretation	Example
Small number (< current time - 100000)	Relative time - minutes from now	5 → 5 minutes from now
Large number	Absolute Unix timestamp in minutes	1710000000 → specific future time
Zero or past time	Executes immediately (bypasses scheduler)	0 → runs almost instantly

Common Use Cases

1. Send Reminder Email

Send a reminder email 24 hours after user signs up.

Timer ID: signupReminder_{{UserID}}
Delay: 1440 (24 hours)
Restart Timer: Off
Iterate Path: Call API to send reminder email

2. Recurring Daily Report

Generate daily report at midnight.

Timer ID: dailyReport
Delay: ={{Time2Midnight}}
Restart Timer: On (prevents duplicates)
Iterate Path: Generate report, then schedule next day's report (recursive)

3. Retry with Delay

Retry failed API call after 5 minutes.

Timer ID: apiRetry_{{DelayedMinutes}}
Delay: 5
Iterate Path: Call API, route based on success/failure

4. Timeout Check

Check if order processing completed after 30 minutes.

Timer ID: orderTimeout_{{Minutes}}
Delay: 30
Iterate Path: Fetch order status, send alert if still pending

5. Hourly Data Sync

Sync data from external system every hour on the hour.

Timer ID: hourlySync
Delay: 60
Restart Timer: On
On The Minute: On
Iterate Path: Fetch data, save results, schedule next sync

Key Behaviors

Feature	Behavior
Variable Snapshot	All flow variables captured when schedule created - changes after don't affect scheduled execution
Independent Execution	Scheduled path runs in new flow instance - cannot return data to original flow
Restart Timer	When enabled, cancels all existing schedules with same Timer ID before creating new one
Persists Across Breaks	✓ Scheduled executions persist even if flow is stopped and restarted (as long as flow is enabled)
Immediate Execution	If delay is 0 or in the past, executes almost immediately (bypasses database)
Operator Isolation	Timer ID automatically suffixed with operator ID - schedules isolated between operators

Important note about breaks: Even if you stop a flow, scheduled executions will still run at their scheduled time as long as the flow is enabled. This ensures reliable delayed processing.

Best Practices

✓ Use descriptive Timer IDs that include entity identifiers (e.g., reminder_{{userId}}_{{orderId}})
✓ Enable "Restart Timer" for recurring schedules to prevent duplicate executions
✓ Use "On The Minute" for synchronized tasks that should align across flows
✓ Store results from scheduled path to persistent storage (can't return to original flow)
✓ Implement recursive scheduling for recurring tasks (schedule next execution from within Iterate path)
✓ Use relative times (5, 60, 1440) rather than calculating Unix timestamps manually
✓ Add Log stages in Iterate path for monitoring scheduled executions
✓ Test with short delays first (1-2 minutes) before using long delays
✓ Minimize flow variables before scheduling (large dictionaries increase overhead)

Common Mistakes

Mistake	Symptom	Fix
Expecting scheduled path to return to main flow	Results from Iterate path not available in main flow	Save results to storage in Iterate path, fetch in subsequent flow runs
Not connecting Iterate exit	Schedule created but nothing happens at scheduled time	Always connect stages to Iterate exit - these run at scheduled time
Using duplicate Timer IDs without Restart	Multiple executions triggered at same time	Enable "Restart Timer" for recurring schedules or use unique Timer IDs
Not cleaning up recurring schedules	Endless schedules accumulate over time	Use Cancel run later stage when schedule no longer needed
Expecting variables set after Run later to be in scheduled execution	Scheduled path missing expected variables	Variables captured at moment Run later executes - changes after don't affect schedule

Troubleshooting

Issue	Exit/Result	Common Cause	Fix
Scheduled execution doesn't run	N/A	Flow disabled or Iterate exit not connected	Ensure flow is enabled; verify stages connected to Iterate exit
Duplicate executions occur	N/A	Same Timer ID used without Restart Timer enabled	Enable "Restart Timer" or use unique Timer IDs with entity identifiers
Variables missing in scheduled execution	N/A	Variables set after Run later stage or snapshot timing issue	Set all required variables before Run later stage
Schedule executes at wrong time	N/A	Delay value interpreted as absolute instead of relative (or vice versa)	Use values < 100000 for relative time (minutes from now)
Can't cancel schedule	N/A	Timer ID doesn't match (operator suffix difference)	Use exact same Timer ID in Cancel run later stage

System Variables

You can use system variables in the Delay field for dynamic scheduling:

Variable	Description	Use Case
`@Now`	Current time in Unix minutes	Calculate absolute future timestamps
`@UnixMillis`	Current time in Unix milliseconds	Convert to minutes for precise scheduling

Edge Cases

Delay of Zero: Executes almost immediately via message queue (bypasses scheduler database).
Delay in the Past: Executes immediately like delay of zero - useful for conditional immediate execution.
Very Long Delays: No explicit maximum - schedules can be years in the future (limited by Unix timestamp range).
Concurrent Schedules with Same Timer ID: Without "Restart Timer", multiple schedules created and all execute. Enable "Restart Timer" to prevent.
On The Minute Precision: When enabled, executes at second 00 of target minute. When disabled, includes current seconds in calculation.
Large Variable Dictionaries: All variables serialized and stored - very large dictionaries may impact performance.
Flow Version Changes: Scheduled execution uses flow version from time of schedule creation, not current version.

Related Stages

Cancel run later: Cancel a previously created schedule using Timer ID
Loop: Process items immediately vs scheduling future processing
Route Flow: Conditional scheduling based on conditions
Change Data: Set variables before scheduling (captured in snapshot)
Save Data: Persist schedule metadata or results from scheduled execution