ExamFinch.com My Study

Study guide

2.2 Configuration Management: Settings, Constants, and Assets

Practice this exam

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

2.2 Configuration Management: Settings, Constants, and Assets

Key Takeaways Explain This Topic AI

REFramework reads Data\Config.xlsx into an in-memory Dictionary(Of String, Object) named Config during the first run of Initialization.

The workbook has three sheets: Settings (environment values, including OrchestratorQueueName and OrchestratorQueueFolder), Constants (framework behavior such as MaxRetryNumber, MaxConsecutiveSystemExceptions, and ShouldMarkJobAsFaulted), and Assets (Orchestrator assets to load).

Values in Config are stored as Object and must be converted with .ToString , CInt , CBool , or Convert methods before use.

A missing asset only logs a Warn in the standard InitAllSettings.xaml, so mandatory assets need an explicit check.

Store only credential asset names in Config.xlsx; fetch the secret with Get Credential inside the login workflow.

Last updated: September 2026

2.2 Configuration Management: Settings, Constants, and Assets

Core Concept: Enterprise automation solutions must strictly separate program logic from operational parameters. UiPath REFramework implements externalized configuration through Data\Config.xlsx and the InitAllSettings.xaml workflow. At runtime, these parameters are compiled into an in-memory Dictionary<string, object> , ensuring that environment endpoints, operational thresholds, and Orchestrator assets can be altered without modifying or recompiling the underlying automation package.

Hardcoded strings, static timeouts, and embedded environment URLs represent severe technical debt in enterprise RPA. If a test server changes its DNS hostname or an API gateway timeout requires extension from 30 seconds to 60 seconds, a hardcoded process requires source code modification, version bumping, peer review, and re-deployment through CI/CD pipelines. By isolating variables in Data\Config.xlsx and UiPath Orchestrator, developers ensure that processes remain fully configurable across Development, Test, UAT, and Production environments.

1. Anatomy of Data\Config.xlsx

The standard configuration file is stored in the project's root subdirectory under Data\Config.xlsx . It is structured into three standard worksheets, each serving a distinct operational role: Data\Config.xlsx

  • ├── [Worksheet] Settings --> Business & Environment-specific parameters (URLs, file paths, switches)
  • ├── [Worksheet] Constants --> Core Framework mechanics & thresholds (MaxRetryNumber, timeouts, queue names)
  • └── [Worksheet] Assets --> UiPath Orchestrator Assets to fetch dynamically at startup
  • The Settings Sheet

The Settings sheet houses environment-specific and business-level parameters. It contains three columns: Name , Value , and Description .

Name : The unique string key used to index the configuration dictionary (e.g., "ACME_URL" , "InvoiceExportDirectory" , "BatchProcessingLimit" ).

Value : The setting value (e.g., "https://acme-test.uipath.com" , "C:\Automation\Invoices\" , 50 ).

Description : Human-readable documentation detailing what the parameter controls, its acceptable values, and which systems it impacts.

Typical entries on the Settings sheet include portal URLs, shared network folder paths, email notification distribution lists, and feature toggles (such as "EnableDetailedLogging" = True ). The template itself ships with three rows here: OrchestratorQueueName , OrchestratorQueueFolder , and logF_BusinessProcessName .

The Constants Sheet

The Constants sheet defines how the framework itself behaves. Like Settings, it uses Name , Value , and Description columns. The values below are the ones the template ships with. Teams often add rows such as timeout values, but those are project additions, not template defaults.

Constant Template value What it controls

MaxRetryNumber 0 Robot-level retries after a System Exception for non-queue data. The template's description says it must stay 0 when working with Orchestrator queues.

MaxConsecutiveSystemExceptions 0 Stops the job after this many System Exceptions in a row; 0 disables the check.

ExScreenshotsFolderPath Exceptions_Screenshots Folder (relative or full path) where TakeScreenshot.xaml saves error screenshots.

LogMessage_GetTransactionData , LogMessage_Success , LogMessage_BusinessRuleException , LogMessage_ApplicationException Text Static parts of the framework's standard log messages.

ExceptionMessage_ConsecutiveErrors Text Message used when the consecutive-exceptions limit stops the job.

RetryNumberGetTransactionItem , RetryNumberSetTransactionStatus Number How many times the framework retries the Orchestrator calls that fetch an item or set its status.

ShouldMarkJobAsFaulted False When True , a System Exception in Initialization (including the consecutive-exceptions stop) ends the job as Faulted instead of Successful .

Note

OrchestratorQueueName and OrchestratorQueueFolder sit on the Settings sheet, not on Constants. Questions about where a key belongs are common.

The Assets Sheet

The Assets sheet links the robot to centralized, centrally managed configuration objects stored within UiPath Orchestrator. The sheet contains four columns:

Asset : The exact asset name as registered in UiPath Orchestrator.

Name : The local key name under which the retrieved asset value will be stored inside the Config dictionary. In standard implementations, Name is set identical to Asset .

OrchestratorAssetFolder : The Orchestrator folder (such as "Shared" , "Finance/Production" , or empty for default root folder) containing the asset.

Description : Informational context outlining the asset's purpose and security classification.

2. Execution Mechanics of InitAllSettings.xaml

The InitAllSettings.xaml workflow is responsible for reading Data\Config.xlsx and constructing the dictionary. The workflow follows a strict sequence of operations: [Start InitAllSettings]

  • │
  • ▼
  • [Initialize Dictionary: Config = New Dictionary(Of String, Object)]
  • │
  • ▼
  • [For Each Sheet in {"Settings", "Constants"}]
  • │
  • ├─► [Read Range: Read sheet into DataTable]
  • │
  • └─► [For Each Row in DataTable]
  • │
  • ├─► [Check: Not String.IsNullOrWhiteSpace(row("Name").ToString.Trim)]
  • │
  • └─► [Assign: Config(row("Name").ToString.Trim) = row("Value")]
  • │
  • ▼
  • [Read Range: Read "Assets" sheet into dt_Assets]
  • │
  • ▼
  • [For Each Row in dt_Assets]
  • │
  • └─► [TryCatch Block]
  • │
  • ├─► [Get Asset Activity (using row("Asset") and folder)]
  • │
  • ├─► [Assign: Config(row("Name").ToString.Trim) = AssetValue]
  • │
  • └─► [Catch Exception: log a Warn message and continue]
  • │
  • ▼
  • [Output: out_Config returned to Main.xaml]

Step-by-Step Breakdown:

Dictionary Instantiation: out_Config = New Dictionary(Of String, Object)

The dictionary is initialized with string keys and Object values, allowing it to store heterogeneous data types.

Parsing Local Sheets ( Settings and Constants ):

The workflow loops over an array of sheet names: {"Settings", "Constants"} .

The Read Range activity loads each sheet into a temporary DataTable .

A For Each Row activity iterates through the rows, filtering out blank lines or header comments: If Not String.IsNullOrWhiteSpace(row("Name").ToString.Trim) Then

  • out_Config(row("Name").ToString.Trim) = row("Value")
  • End If

Resolving Orchestrator Assets:

The workflow reads the Assets sheet into dt_Assets .

For each row containing a non-empty Asset name, the workflow executes the Get Asset activity.

If an Orchestrator folder is specified in row("OrchestratorAssetFolder") , the activity directs the query to that specific folder hierarchy.

The returned asset value is stored into the dictionary under row("Name").ToString.Trim .

Defensive Asset Exception Handling:

Each asset lookup sits inside a TryCatch activity.

If an asset cannot be found (misspelled name, wrong folder, or missing permission), the template logs a Warn message such as Loading asset ACME_URL failed: ... and moves on to the next row. It does not rethrow.

The key is simply never added to Config , so the problem surfaces later as a KeyNotFoundException the first time a workflow reads that key.

For assets the process cannot run without, add your own check (or a Rethrow in that Catch) so the job fails fast in Initialization rather than in the middle of a transaction.

3. Data Boxing and Type Casting in VB.NET

Because the Config dictionary is defined as Dictionary<string, object> , every value stored inside it is boxed as a System.Object . When accessing parameters in business workflows, developers must unbox or cast the object into its strongly typed representation. ' Common Unboxing and Conversion Patterns in REFramework (VB.NET)

  • ' 1. String Extraction
  • Dim targetUrl As String = Config("ACME_URL").ToString
  • ' 2. Integer Conversion (Timeouts, Counters, Port Numbers)
  • Dim timeoutMs As Integer = Convert.ToInt32(Config("TimeoutMedium"))
  • Dim maxRetries As Integer = CInt(Config("MaxRetryNumber"))
  • ' 3. Boolean Conversion (Feature Flags, Switches)
  • Dim isDebugMode As Boolean = Convert.ToBoolean(Config("EnableDebugMode"))
  • Dim autoSendEmail As Boolean = CBool(Config("SendNotificationEmails"))
  • ' 4. Double / Decimal Conversion (Financial thresholds, limits)
  • Dim approvalThreshold As Double = CDbl(Config("InvoiceThresholdAmount"))
  • ' 5. TimeSpan Conversion
  • Dim delayDuration As TimeSpan = TimeSpan.FromSeconds(Convert.ToDouble(Config("DelayBetweenRequests")))
  • Defensive Key Access

Attempting to access a key that does not exist in the dictionary throws a System.Collections.Generic.KeyNotFoundException: The given key was not present in the dictionary .

To prevent unhandled runtime errors when reading optional settings, developers use defensive ternary checks: ' Safe Dictionary Access Pattern

  • Dim reportFolder As String = If(Config.ContainsKey("ReportDirectory"),
  • Config("ReportDirectory").ToString,
  • "C:\DefaultReports\")
  • 4. Orchestrator Assets vs. Local Settings

Architecting enterprise automations requires deciding which parameters belong in Data\Config.xlsx and which belong in UiPath Orchestrator Assets :

Evaluation Criteria Local Data\Config.xlsx (Settings/Constants) UiPath Orchestrator Assets

Update Mechanism Requires updating file in project package and redeploying. Real-time update via Orchestrator Web UI or API without package redeployment.

Security & Encryption Plaintext stored on disk; insecure for passwords or secret tokens. Encrypted in Orchestrator database; supports AES-256 encrypted Credential Assets.

Scope & Sharing Strictly local to the specific robot and process package. Can be shared across multiple robots, departments, processes, and folders.

Environment Promotion Values must be manually adjusted or swapped per environment branch. Identical code uses same asset name; Dev/UAT/Prod folders provide environment-specific values.

Best Used For Fixed framework timeouts, internal constants, standard folder naming. System URLs, API keys, operational feature flags, credentials, environment switches.

Managing Credentials Securely

Caution

Never store plaintext passwords, secret keys, or access tokens in Data\Config.xlsx .

The enterprise best practice for managing login credentials in REFramework is:

Store the credential in UiPath Orchestrator as an Asset of type Credential .

In Data\Config.xlsx under the Assets or Settings sheet, store only the name of the credential asset (e.g., "ACME_Credential" ).

Inside the specific application login workflow (e.g., ACME_Login.xaml ), pass Config("ACME_Credential").ToString into a Get Credential activity.

The Get Credential activity outputs the username as a String and the password as a System.Security.SecureString .

Pass the SecureString directly into modern Type Into (with SecureText enabled) or Use Application/Browser activities without ever converting it to plaintext in memory. +-----------------------------------------------------------------------------------+

  • | SECURE CREDENTIAL ARCHITECTURE |
  • | |
  • | [Config.xlsx] [UiPath Orchestrator] |
  • | Key: "ACME_CredentialName" Asset Name: "ACME_Credential" |
  • | Value: "ACME_Credential" Type: Credential (Encrypted) |
  • | │ │ |
  • | ▼ ▼ |
  • | [Main.xaml / Config Dictionary] │ |
  • | Config("ACME_CredentialName") ──────────────┤ |
  • | ▼ |
  • | [Get Credential Activity] |
  • | in_CredentialName = "ACME_Credential" |
  • | │ |
  • | ┌────────┴────────┐ |
  • | ▼ ▼ |
  • | out_Username out_Password |
  • | (String) (System.Security.SecureString) |
  • | │ │ |
  • | └────────┬────────┘ |
  • | ▼ |
  • | [Type Into (Secure)] |
  • +-----------------------------------------------------------------------------------+
  • 5. Architectural Best Practices for Configuration Management

Treat Config as Read-Only at Runtime: The Config dictionary should be populated strictly during Initialization . Do not write code that modifies or inserts keys into Config during Process Transaction . Mutating global configuration during transactional execution creates race conditions, impairs debugging, and violates modular workflow encapsulation.

Pass in_Config Strictly by Value: When invoking child workflows from Main.xaml or Process.xaml , pass the configuration object using the direction In ( in_Config ). Do not use InOut ( io_Config ) unless a workflow's explicit purpose is configuration modification.

Standardize Naming Conventions: Prefix asset keys logically to clarify their system affiliation and type (e.g., ACME_URL , ACME_Credential , SAP_ClientNumber , Timeout_Short ).

Modern Folder Scoping: Always populate the OrchestratorAssetFolder column when working in modern Orchestrator folder hierarchies. This ensures the robot queries the correct tenant subfolder rather than failing on an ambiguous asset query.