Study guide

11.3 Bulk Operations, Transaction Status Updates & Queue Triggers

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

11.3 Bulk Operations, Transaction Status Updates & Queue Triggers

Key Takeaways Explain This Topic AI

Bulk Add Queue Items adds up to 15,000 DataTable rows per call; each column becomes a SpecificContent key.

CommitType AllOrNothing adds nothing if any row fails, while ProcessAllIndependently adds valid rows and returns the failures in the Result DataTable.

Set Transaction Status closes an item as Successful or Failed; Failed needs ErrorType Business (never auto-retried) or Application (retried if the queue allows).

Queue triggers start jobs automatically as items arrive, controlled by the minimum items to start the first job, the number of new items per additional job, and the maximum pending and running jobs.

An item whose robot never sets a status stays In Progress and becomes Abandoned after about 24 hours.

Last updated: September 2026

11.3 Bulk Operations, Transaction Status Updates & Queue Triggers

Core Concept: Enterprise automation requires efficient high-throughput data ingestion, robust transactional status reporting, and reactive, event-driven process initiation. Using the Bulk Add Queue Items activity, Dispatcher robots ingest thousands of records in a single optimized API request. Performer robots finalize transaction states using Set Transaction Status with granular diagnostic payloads. Finally, Queue Triggers provide dynamic elasticity, automatically provisioning unattended robot jobs as queue volumes surge and terminating them when queues drain.

In early-stage RPA deployments, scheduling is often implemented using rigid time-based CRON schedules (e.g., "execute every day at 08:00 AM"). In enterprise production, however, work arrives unpredictably: batch files land late, customer web portals experience sudden transaction spikes, or regulatory filings arrive in large unexpected bursts. Modern UiPath architectures eliminate idle polling and processing lag by combining high-speed batch operations with event-driven Queue Triggers.

1. Queue Ingestion at Scale: Add Queue Item vs. Bulk Add Queue Items

UiPath Studio provides two primary mechanisms for uploading transaction payloads into an Orchestrator Queue: the iterative Add Queue Item activity and the batch-oriented Bulk Add Queue Items activity. +--------------------------------------------------------------------------+

  • | QUEUE INGESTION ARCHITECTURES |
  • | |
  • | SCENARIO A: Iterative Add Queue Item (High Network Overhead) |
  • | [Robot] -- HTTP POST (1 Item) --> [Orchestrator DB] |
  • | [Robot] -- HTTP POST (1 Item) --> [Orchestrator DB] |
  • | [Robot] -- HTTP POST (1 Item) --> [Orchestrator DB] (x 5,000 requests) |
  • | |
  • | SCENARIO B: Bulk Add Queue Items (Optimized Batch Architecture) |
  • | [DataTable: 5,000 Rows] |
  • | | |
  • | v (Single Serialized HTTP POST Payload) |
  • | [Robot] ========================================> [Orchestrator DB] |
  • +--------------------------------------------------------------------------+
  • Architectural Comparison
  • Architectural Attribute Add Queue Item Bulk Add Queue Items
  • Input Data Structure Individual properties & dictionary items System.Data.DataTable
  • API Call Frequency 1 HTTP POST request per individual item 1 HTTP POST request per batch (up to 15,000 items)
  • Network Overhead High (TLS handshakes, connection overhead per item) Extremely Low (Single serialized payload)
  • Ingestion Throughput One request per item Many items per request, which is far faster for large batches

Item Reference Field Explicit Reference string property Comes from the DataTable's column mapping, such as a Reference column

SpecificContent Mapping Manually configured key-value pairs Automatic: Each column header becomes a dictionary key

Error Handling Output Throws an exception for a failed item The Result output DataTable lists rows that could not be added

Working with Bulk Add Queue Items

Input Format: Accepts a standard DataTable . Every column header in the DataTable becomes a string key in the SpecificContent dictionary of each generated queue item, and the row values become the corresponding dictionary values.

Batch Size Limit: The activity supports up to 15,000 records in a single batch call. If a DataTable exceeds 15,000 rows, developers should partition the data into chunks (using LINQ .Skip() and .Take() ) and execute Bulk Add Queue Items in a loop.

Reference Mapping: UiPath notes that the DataTable can also carry references, depending on how its columns are mapped; a column named Reference supplies each item's reference. There is no separate reference-column property on the activity.

CommitType and the Result output: Bulk Add Queue Items has two commit types:

AllOrNothing adds every item only if no error occurs; on an error, nothing is added and the failing row is returned.

ProcessAllIndependently adds each item individually and returns the items that could not be added, such as duplicates on a queue with unique references.

The Result output is a DataTable holding those errors, so the dispatcher can log or reprocess them.

Permissions: the robot needs Queues View , Transactions Create , and Folders View on the target folder. ' Partitioning a large DataTable into 10,000-row chunks for Bulk Add

  • Dim intBatchSize As Integer = 10000
  • Dim intTotalRows As Integer = dt_MasterTransactions.Rows.Count
  • Dim intOffset As Integer = 0
  • While intOffset < intTotalRows
  • Dim dt_Batch As DataTable = dt_MasterTransactions.AsEnumerable() _
  • .Skip(intOffset) _
  • .Take(intBatchSize) _
  • .CopyToDataTable()
  • ' Execute Bulk Add Queue Items on dt_Batch
  • ' The Result output captures rows that could not be added
  • intOffset = intOffset + intBatchSize
  • End While
  • 2. Finalizing Transactions: Set Transaction Status

When a Performer robot processes a QueueItem , it must commit the final processing outcome back to Orchestrator using the Set Transaction Status activity. This transitions the item from In Progress to a terminal state.

Activity Parameters & Properties

Status : Specifies the final state: Successful or Failed .

ErrorType : Required when Status = Failed :

Business : Used for anticipated business logic violations (e.g., insufficient account funds, unsupported country code). Caught via Catch ex As BusinessRuleException . Orchestrator marks the item as Failed and never retries it.

Application : Used for unhandled technical faults (e.g., SQL server timeout, SAP GUI crash). Caught via Catch ex As Exception . Orchestrator marks the item as Retried (if retries remain) or Failed (if retries are exhausted).

Reason : A short description of the failure, shown with the item in Orchestrator.

Details : Granular diagnostic data (e.g., ex.ToString including full stack trace, inner exceptions, and current application window titles).

Output : A Dictionary(Of String, Object) containing computed business outcomes returned by the automation (e.g., payment confirmation codes, approval timestamps).

Analytics : A Dictionary(Of String, Object) capturing custom metrics for UiPath Insights .

Caution

If an unhandled crash or developer oversight causes a robot to terminate without executing Set Transaction Status , the item remains locked in In Progress status. It will remain locked to other robots until Orchestrator's 24-hour maintenance threshold converts it to Abandoned .

Loading diagram... Set Transaction Status Exception Branching

3. Event-Driven Automation: Queue Triggers in Orchestrator

Traditional automation workflows rely heavily on time-based triggers (CRON schedules), launching jobs at predefined calendar intervals. However, time-based triggers suffer from two major architectural flaws:

Resource Inefficiency: A robot scheduled to run every 15 minutes may wake up, find zero items in the queue, and terminate. This consumes machine runtime, generates redundant log noise, and ties up unattended licenses needed by other processes.

Processing Latency: If 500 invoices arrive at 08:01 AM and the schedule does not run until 09:00 AM, items sit idle for 59 minutes, risking SLA breaches.

Queue Triggers address both problems: they start jobs based on the number of New items in the queue, so work starts soon after items arrive and no jobs start when the queue is empty.

4. Queue Trigger Configuration & Dynamic Auto-Scaling

When configuring a Queue Trigger in Orchestrator (under Automations → Triggers → Queue Triggers ), administrators pick the process and queue and set three scaling thresholds: +--------------------------------------------------------------------------+

  • | QUEUE TRIGGER CONFIGURATION |
  • | |
  • | Process Name: Production_Invoice_Performer |
  • | Target Queue: Invoices_Processing_Queue |
  • | |
  • | [x] Minimum number of items to trigger the first job: 1 |
  • | [x] Another job is triggered for each X new items: 10 |
  • | [x] Maximum number of pending and running jobs allowed simultaneously: 4|
  • +--------------------------------------------------------------------------+
  • The Three Scaling Thresholds

Minimum number of items to trigger the first job ( M ):

The threshold of items with status New that must exist in the queue before Orchestrator starts the initial job.

Low-Latency Config ( M = 1): As soon as a single item arrives, a job launches immediately.

Batch Efficiency Config ( M = 20): Ensures jobs only launch when enough work exists to justify application initialization overhead.

Another job is triggered for each X new items ( S ):

The scaling step increment. Orchestrator triggers an additional parallel job for each multiple of X unhandled items.

For example, if M = 1 and S = 10:

  • 1 to 10 items in queue → 1 Job
  • 11 to 20 items in queue → 2 Jobs
  • 21 to 30 items in queue → 3 Jobs

Maximum number of pending and running jobs allowed simultaneously ( J_max ):

The hard ceiling on concurrency. Regardless of how high the queue volume spikes, Orchestrator will never allow the total count of running plus pending jobs for this trigger to exceed this number.

Governance Safeguard: Prevents an unexpected spike of 50,000 items from consuming every available unattended robot license in the tenant, which would starve other critical enterprise processes.

Auto-Scaling Logic

The total target number of concurrent jobs ( J ) calculated by Orchestrator based on the count of unhandled items ( N ) follows this deterministic relationship: Target Jobs (J) = Min(J_max, 1 + Floor((N - M) / S)) [for N >= M]

Concrete Auto-Scaling Walkthrough

Assume a Queue Trigger is configured with:

  • Minimum items for first job ( M ): 1
  • Another job triggered for each X items ( S ): 15
  • Maximum simultaneous jobs ( J_max ): 3
  • Operational Event Sequence: [Time 09:00] Queue Count = 0 --> Jobs Running = 0

[Time 09:05] Dispatcher uploads 5 items:

- Queue Count = 5 >= 1 --> Orchestrator launches Job #1.

- Jobs Running = 1.

[Time 09:07] Dispatcher uploads an additional 30 items:

- Total New Items = 35.

- Calculation: 1 + Floor((35 - 1) / 15) = 1 + Floor(34 / 15) = 1 + 2 = 3 Jobs.

- Orchestrator triggers Job #2 and Job #3.

- Jobs Running = 3.

[Time 09:10] Dispatcher uploads 100 more items:

- Total New Items = 120.

- Calculation yields 1 + Floor(119 / 15) = 8 Jobs.

- However, J_max = 3. Orchestrator enforces the ceiling.

- Jobs Running = 3 (Max Limit Preserved).

[Time 09:30] Robots consume items; New items drop to 0:

- Each Performer robot calls Get Transaction Item, receives Nothing, and

transitions cleanly to End Process.

- Jobs Running naturally scales back down to 0.

This dynamic auto-scaling architecture delivers the pinnacle of operational efficiency: instant responsiveness during demand surges, strict licensing governance, and zero wasted robot runtimes during idle periods.

Loading diagram... Queue Trigger Dynamic Auto-Scaling Dynamics