Study guide

4.1 Building State Machine Projects in Studio

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

4.1 Building State Machine Projects in Studio

Key Takeaways Explain This Topic AI

A State has Entry, Exit, and Transition(s) sections; a Final State has only an Entry section.

A state machine has exactly one initial state but can have more than one Final State.

A transition has a Trigger, a Condition, and an Action; after the trigger completes, the first true condition wins, and the source Exit runs before the transition Action.

Choose a state machine for named stages that repeat or recover to earlier stages; choose a flowchart for forward-moving decision logic.

Last updated: September 2026

4.1 Building State Machine Projects in Studio

Core Concept: A state machine is a workflow type that is always in exactly one of a finite set of states. It moves between states along transitions whose conditions (and optional triggers) decide the next state. REFramework is the best-known example, but the exam description also asks you to describe the components of state machines and build your own . That means knowing what each part does and when a state machine is a better fit than a flowchart.

The Building Blocks

Studio provides two activities specific to state machines, under Workflow > State Machine , plus the State Machine container itself:

Element Sections Rules

State Machine (container) Holds the states and the Start node Created with New > State Machine on the Design tab, or by adding a State Machine activity

  • State Entry , Exit , Transition(s) Entry runs when the state is entered; Exit runs when the state is left
  • Final State Entry only Ends the state machine; it has no Exit section and no outgoing transitions

Transition Trigger , Condition , Action Connects a source state to a target state; the Action runs while moving

Two structural rules are easy to test:

A state machine has exactly one initial state , the one connected to the Start node.

It can have more than one Final State , for example Completed and Cancelled.

How a transition is chosen

After a state's Entry section finishes, the state machine evaluates its outgoing transitions:

If a transition has a Trigger (an activity such as a Delay or an event wait), the transition waits for that trigger to complete. Transitions without a trigger are ready immediately.

Once the trigger has completed, its Condition is checked. A transition with an empty condition is treated as true.

The first transition whose condition is true is taken. The source state's Exit section runs, then the transition's Action , and then the target state's Entry .

Several transitions can share the same trigger and differ only in their conditions. REFramework's Process Transaction state works that way: Success, Business Exception, and System Exception have no triggers and are separated only by their conditions.

Worked Example: A Guess-the-Number Machine

UiPath's own documentation uses a guessing game to show all the parts:

Initializing Random Number (initial state). The Entry section contains RandomNumber = New Random().Next(1, 100) .

Guess Number (state). The Entry section contains an Input Dialog that stores the user's value in InitialGuess .

Transition Try Smaller , from Guess Number back to itself. Condition InitialGuess > RandomNumber ; the Action shows a "too big" message.

Transition Try Bigger , from Guess Number back to itself. Condition InitialGuess < RandomNumber ; the Action shows a "too small" message.

Transition Correct Guess , from Guess Number to a Final State . Condition InitialGuess = RandomNumber ; the Final State's Entry congratulates the user.

This shows three patterns you will reuse: a self-transition for loops, conditions that divide possibilities between transitions, and a Final State to end.

When to Choose a State Machine

Use a state machine when... Use a flowchart when...

The process has clear, named stages that can repeat (initialize, fetch, process, finish) The logic is a decision tree that mostly moves forward

Recovery means going back to an earlier stage, as REFramework does after a System Exception Loops are local and simple

  • Events or timers decide what happens next, as in attended waiting stages No event waits are needed
  • You want each stage's cleanup in an Exit section Cleanup can be ordinary activities

A state machine is a poor fit for a short linear task: the extra states add ceremony without adding control.

Design Practices

Name states and transitions with their business meaning. The names appear on the designer arrows and in logs, which makes debugging easier.

Keep states thin. Put real work in invoked workflows, as REFramework does with Process.xaml , so the state machine shows only the control flow.

Make conditions mutually exclusive. If two transitions can both be true, the outcome depends on evaluation order, which is hard to review.

Declare shared variables at the state machine level. Variables scoped to a single state are not visible to transition conditions that leave other states.

Always provide a way out. Every non-final state should have a reachable path to a Final State, or the job can loop forever.

Use triggers for waiting , for example a Delay trigger on a retry-later transition, instead of busy-wait loops inside Entry sections.

Loading diagram...