17.1 Long-Running Workflows: Persistence, Suspend and Resume

UiPath Automation Developer Professional UiPath-ADPv1

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Exam Overview & Blueprint Map

1.1 About the UiPath-ADPv1 Exam: Format, Fees & Policies 1.2 The Exam Topics Mapped to This Guide & a Study Plan

2 Chapter 2: REFramework Architecture & State Dynamics

2.1 State Machine Architecture & The Four Core States 2.2 Configuration Management: Settings, Constants, and Assets 2.3 Transaction Types & The Dispatcher vs. Performer Architecture 2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes

3 Chapter 3: REFramework Exception Handling & Recovery

3.1 BusinessRuleException vs. System.Exception Handling Patterns 3.2 Retry Mechanisms: Queue Retries vs. REFramework MaxRetryNumber 3.3 Consecutive System Exceptions & Graceful Process Termination

4 Chapter 4: State Machines, Custom Log Fields & REFramework Testing

4.1 Building State Machine Projects in Studio 4.2 Logging Levels, Robot Logs & Custom Log Fields in REFramework 4.3 Testing a REFramework Project With and Without Orchestrator Queues

5 Chapter 5: LINQ Queries & DataTable Operations

5.1 LINQ Essentials for Collections & Filtering 5.2 Advanced DataTable Querying with LINQ 5.3 In-Memory DataTable Transformations & Column Operations

6 Chapter 6: Regex, DateTime, JSON & Invoke Activities

6.1 Regular Expressions & Text Parsing for Automation 6.2 DateTime Formatting, Timezone Conversions & TimeSpan Calculations 6.3 JSON Parsing, JSONPath & Serialization with Newtonsoft.Json 6.4 Invoke Method & Invoke Code Activities 6.5 Data Referencing in Invokes: DataTable, List & Dictionary Arguments

7 Chapter 7: Modern UI Automation & Unified Targeting

7.1 Modern Design Experience & The Unified Target Concept 7.2 Anchors, Relative Elements & UI Automation Activities 7.3 Dynamic Selectors, Variables & Wildcards in Selectors

8 Chapter 8: Object Repository, Computer Vision & Remote Runtime

8.1 Object Repository & UI Descriptor Libraries 8.2 AI Computer Vision for Unattended & Remote Interfaces 8.3 Automation in Virtual Environments & UiPath Remote Runtime

9 Chapter 9: Advanced UI Automation: Browser Modes, Agentic UI & macOS

9.1 Browser Automation with the WebDriver Protocol 9.2 Agentic UI Automation: ScreenPlay, Semantic Activities & Healing Agent 9.3 macOS Automation: Native Apps, Office Apps & AppleScript

10 Chapter 10: Advanced Control Flow & Exception Architecture

10.1 Flowcharts, Sequences & Parallel Control Flow Patterns 10.2 Global Exception Handler Architecture & ErrorAction Directives 10.3 TryCatch, Retry Scope & Custom Exception Architectures

11 Chapter 11: Orchestrator Queues & Transaction Management

11.1 Queue Architecture, SpecificContent & Transaction Lifecycles 11.2 Queue Items SLA, Postpone, Deadlines & Priority Scheduling 11.3 Bulk Operations, Transaction Status Updates & Queue Triggers

12 Chapter 12: Orchestrator Tenant & Folder Entities

12.1 Asset Types, Per-Robot Assets & External Credential Stores 12.2 Modern Folder Hierarchy, User/Robot Assignment & Permissions 12.3 Storage Buckets, Webhooks & Environment Promotion 12.4 Orchestrator Tags: Labels, Properties & Governance

13 Chapter 13: Unattended Execution, API Triggers & Cloud Robots

13.1 Unattended Job Execution: Folders, Priorities, Background vs. Foreground & Runtimes 13.2 API Triggers: Starting Jobs from External Systems over HTTP 13.3 Serverless and Cloud VM Robots: Cloud-Hosted Execution Options

14 Chapter 14: Monitoring, Recording & Solutions Management

14.1 Orchestrator Monitoring, Trigger Alerts & Job Health 14.2 Job and Transaction Recording: Troubleshooting Faulted Unattended Jobs 14.3 Solutions Management: Packaging and Deploying Automations with Their Resources

15 Chapter 15: Debugging, Remote Debugging & Profiling

15.1 Studio Debugging Tools: Breakpoints, Panels & Execution Control 15.2 Remote Debugging: Remote Machine and Unattended Robot Connections 15.3 Profile Execution: Finding Performance Bottlenecks in Studio

16 Chapter 16: RPA Testing & Test Suite

16.1 UiPath Test Suite Overview, Test Cases & Given-When-Then Structure 16.2 Data-Driven Testing, Test Verification Activities & Mock Activities 16.3 CI/CD Pipelines with uipcli & Test Manager Traceability

17 Chapter 17: Long-Running Workflows, Action Center & Apps

17.1 Long-Running Workflows: Persistence, Suspend and Resume 17.2 Action Center & Human-in-the-Loop Orchestration 17.3 UiPath Apps: Action Apps, Automations & Integration Service

18 Chapter 18: Trigger-Based Attended Automation & Callouts

18.1 Trigger-Based Attended Automation: Forms, Triggers & Global Variables 18.2 Running Local Triggers & the Event Inspection Tool 18.3 Callouts & Forms for Attended Guidance

19 Chapter 19: UiPath Assistant & Robot Sessions

19.1 UiPath Assistant: Automations, Reminders, Widgets & Configuration 19.2 Robot Session (Picture in Picture): Child Session vs. Virtual Desktop

20 Chapter 20: Autopilot for Developers & Autopilot for Everyone

20.1 Autopilot for Developers: AI Assistance in Studio and Studio Web 20.2 Autopilot for Everyone: Chat, Automations & Clipboard AI

21 Chapter 21: API Automation & Integration Service

21.1 Integration Service: Connectors, Connections & Connector Activities 21.2 API Workflows in Studio Web 21.3 HTTP Requests: Web APIs, the Orchestrator API & Connector Requests 21.4 Connector Builder: Custom Integration Service Connectors 21.5 Integration Service Event Triggers: Connected and Disconnected 21.6 GenAI Activities: Generative AI Inside Workflows

22 Chapter 22: Data Service, Context Grounding & Coded Workflows

22.1 Data Fabric (Data Service) Entities: Modeling Business Data 22.2 Data Fabric Activities and the Platform Connector 22.3 Context Grounding: Retrieval-Augmented Generation with Company Data 22.4 Coded Automations: Structure, Arguments & Invoking Workflows 22.5 Coded Automation Services: Orchestrator, UI Automation, Microsoft 365 & Custom Services

23 Chapter 23: Integrated Scenario Practice

23.1 Integrated Scenario Practice: Designing an End-to-End Solution

17.1 Long-Running Workflows: Persistence, Suspend and Resume

Key Takeaways Explain This Topic AI

Long-running projects use the Long Running Automation template (formerly Orchestration Process) or Supports Persistence, with UiPath.Persistence.Activities.

Start-and-wait pairs cover jobs, queue items, form tasks, app tasks, and external tasks; Resume After Delay waits for time.

At a wait activity the job becomes Suspended and frees the robot, then Resumed on any available robot unless the account-machine allocation is kept.

State in scope across a wait must be serializable, and local files should be replaced by shared storage.

Delay and Retry Scope are not supported in the Main workflow; use Resume After Delay or a No Persist Scope.

Last updated: September 2026

17.1 Long-Running Workflows: Persistence, Suspend and Resume

Core Concept: A long-running workflow can stop in the middle, free its robot, and continue later, possibly on another robot, when something it waits for has happened: a person completes a task, another job finishes, a queue item is processed, or time passes. The exam description lists long-running workflows under attended and human-in-the-loop topics.

Setting Up a Long-Running Project

Start from the Long Running Automation template (formerly Orchestration Process ), or turn on Supports Persistence in Project Settings.

Add the UiPath.Persistence.Activities package.

In the Main workflow, Delay and Retry Scope are not supported; use Resume After Delay , or place them inside a No Persist Scope , where no suspension may happen.

The Create-and-Wait Pairs

Every persistence pattern pairs an activity that starts something and returns a reference with an activity that waits for it and resumes:

Start activity Wait activity What the job waits for

Start Job and Get Reference Wait for Job and Resume Another Orchestrator job to finish; its output arguments are returned

Add Queue Item and Get Reference Wait for Queue Item and Resume A queue item to be processed; its output data is returned

• Create Form Task Wait for Form Task and Resume A person to complete a form task in Action Center
• Create App Task Wait for App Task and Resume A person to complete a task that uses an action app
• Create External Task Wait for External Task and Resume An external system to complete the task
• (none) Resume After Delay A period of time or a date

Because start and wait are separate, a workflow can start several jobs, queue items, or tasks first and then wait for all of them, for example with a Parallel For Each of wait activities.

What Happens at a Wait Activity

The workflow reaches a Wait ... and Resume activity.

The runtime persists the workflow's state, and the job moves to Suspended . The robot is free to run other jobs.

When the awaited event happens, Orchestrator moves the job to Resumed , and an available robot continues from the step after the wait.

By default the job can resume on any available robot and machine. The trigger or job option Keep account-machine allocation on job resumption keeps the original pair.

Consequences to design for:

Everything in scope at a wait must be serializable . UI element handles, open file streams, and database connections are not; close them before the wait and reopen them after.

Local files may not exist after resuming on another machine. Keep files in storage buckets or other shared storage.

Recording captures only the execution after the resume.

Remote debugging of long-running workflows works only with an Unattended Robot connection.

• Orchestrating Other Automations
• Long-running workflows are often coordinators : Main (long-running)
• ├─ Add Queue Item and Get Reference → invoice item for the performer
• ├─ Wait for Queue Item and Resume → job suspends until the item is processed
• ├─ Create App Task → approval task with the performer's output
• ├─ Wait for App Task and Resume → job suspends until the approver submits
• └─ Start Job and Get Reference / Wait for Job and Resume → posting process

The coordinator never holds a robot while people or other processes work. Each step's output feeds the next step.

Timers and Deadlines

Resume After Delay suspends the job for a duration or until a date, without occupying a robot.

To enforce a response deadline on a human task, UiPath offers a task timer (the Configure task timer activity) in the persistence package. A common pattern is also a Parallel activity with a wait branch and a Resume After Delay branch, with a CompletionCondition that ends the other branch when one finishes.

Worked Example: Supplier Onboarding

A form arrives, and the coordinator adds a verification queue item with Add Queue Item and Get Reference.

Wait for Queue Item and Resume suspends the job while an unattended performer checks the supplier's tax ID and bank details.

The coordinator reads the item's output. If checks failed, it creates a form task for the compliance team and waits for it.

If checks passed, it starts the ERP setup process with Start Job and Get Reference and waits for it with Wait for Job and Resume .

Finally it sends a welcome email.

Across the whole flow, the coordinator occupies a robot only for the few seconds between waits, although the onboarding may take days.

Common Traps

Using Delay in the Main workflow of a long-running process instead of Resume After Delay .

Keeping a UI element or DataTable of non-serializable objects in scope across a wait.

Expecting the job to resume on the same machine without enabling the account-machine allocation option.

Waiting for each task right after creating it when several tasks could be created first.