Attended Automation practice questions

Use Input Dialog

Why it fails: Input Dialog is limited to capturing a single string value or simple choice selection. It cannot render multi-field layouts, custom buttons, validation rules, or complex tables required for modern invoice validation tasks.

Message Box

Why it fails: Message Box is restricted to displaying simple notification text and standard buttons like OK and Cancel. It offers zero capability to collect customized user input or display structured business data for validation.

Read Line

Why it fails: Read Line belongs to text file manipulation activities and reads characters sequentially from an open stream. It has no application interface capabilities and cannot interact with human operators in an attended context.

Use the Input Dialog activity and configure the TimeoutMS property to 30000.

Why it fails: The TimeoutMS property specifically controls how long the activity waits for user interaction before returning the default value specified in the activity configuration. This is the standard, built-in mechanism provided by UiPath to handle non-responsive users in attended automation scenarios, ensuring the workflow remains resilient and efficient.

Invoke a separate workflow that uses a Timer to kill the Input Dialog process.

Why it fails: Killing the process hosting the Input Dialog will result in an exception rather than a graceful resumption with a default value. This approach is destructive and violates the requirement to continue the process, as it would likely crash the robot's execution flow or leave the system in an unstable state.

Set the Input Dialog to run in the background using the 'Continue on Error' property.

Why it fails: The 'Continue on Error' property handles unexpected exceptions but does not provide a functional timeout mechanism for the Input Dialog. If the user does not interact with the dialog, the robot will remain stuck waiting indefinitely, regardless of whether 'Continue on Error' is enabled or disabled.

Include periodic 'Check User Activity' triggers to pause execution.

Why it fails: Implementing triggers that monitor user activity allows the robot to yield control immediately when the human starts working. This prevents the robot from competing for focus or input, which is vital for maintaining a positive user experience where the human remains the primary operator of the workstation.

Use the 'Run Parallel' activity to force all steps to run simultaneously.

Why it fails: Running all steps in parallel does not resolve resource contention; it often exacerbates it by consuming more CPU and memory. Forcing parallel execution without careful resource management can lead to UI freezes and instability, making the machine unresponsive to the user and causing the robot process to crash.

Configure the robot to run as a Windows Service.

Why it fails: Windows Services are designed for unattended processes and lack the interactive capabilities required for attended automation. Attempting to force an attended interaction through a service architecture will fail, as there is no session context or UI capabilities available to display prompts or receive user-provided inputs.

Set the Form activity's AutoClose property to False.

Why it fails: AutoClose controls whether the form window closes automatically after the form is submitted or after a timeout, but it does not change the synchronous wait behavior of the Form activity. Even with AutoClose set to False, the activity still blocks the workflow until the form is submitted or the timeout elapses, so it does not address the described symptom and is not the correct fix here.

Enable the Form activity's Isolated property so the form runs in a separate process.

Why it fails: The Isolated property determines whether the form runs in a separate process for security and stability reasons. It does not affect whether the parent workflow waits for the form to be submitted. Enabling isolation would not change the observed behavior of the robot continuing before the user finishes the form, so it is not the appropriate action.

Ensure the Form activity is placed inside the Try block of a Try Catch and the workflow's ContinueOnError property is set to False.

Why it fails: Wrapping the Form activity in a Try Catch changes error handling behavior, not execution timing. ContinueOnError controls whether the activity throws on error; it does not make the robot wait for user input. The Form activity already blocks execution until submission, so this change would not resolve the premature continuation described in the scenario.

Formatted Text

Why it fails: Formatted Text is used to display text with formatting in the output panel or logs. It does not provide any user input mechanism or validation. It is not interactive and thus cannot collect or validate user data.

Input Dialog

Why it fails: Input Dialog supports basic input types and can have multiple fields, but its validation capabilities are limited compared to Custom Input Form. It does not offer the same level of custom validation logic, such as regex or range checks, without additional coding. For complex validation, it is less suitable.

Message Box

Why it fails: Message Box only displays a message and returns a button click. It cannot collect multiple fields or validate numeric input. It is purely for notifications and simple confirmations, so it cannot fulfill the requirement of a custom form with validation.

Set the ContinueOnError property to True.

Why it fails: The Global Exception Handler does not have a ContinueOnError property. ContinueOnError is a property of individual activities, not the exception handler. Setting it would not affect the handler's behavior. The correct property to control whether the exception is rethrown is Rethrow. Setting Rethrow to False allows the process to end gracefully without a default error dialog.

Set the Rethrow property to True.

Why it fails: Setting Rethrow to True causes the exception to be rethrown after the handler executes, which would propagate the error and potentially trigger the default error dialog or terminate the process abruptly. This does not meet the requirement of graceful termination without a dialog. Instead, the developer should set the Rethrow property to False and handle logging and termination within the handler.

Set the LogException property to True.

Why it fails: The Global Exception Handler does not have a LogException property. Logging must be done explicitly within the handler using Log Message or Write Line activities. While logging is part of the requirement, the property to control rethrowing is Rethrow. Setting LogException does not exist and would not prevent the default error dialog. Therefore, configuring Rethrow to False is the correct action.

Message Box

Why it fails: Message Box is used to display information to the user and optionally capture a button click, but it is not intended for free-form data entry such as a customer ID. It only returns which button was clicked, not typed input. Using it would require additional custom logic to capture text, which is inefficient and error-prone for this scenario.

Form Activity (Create Form)

Why it fails: The Form Activity is powerful for complex data entry with multiple fields and custom layouts, but it is overkill for a single customer ID prompt. It requires designing a form in the Form Designer, which adds unnecessary development overhead. While it supports cancellation, the simpler Input Dialog is more appropriate for a single-field input.

Get Secure Credential

Why it fails: Get Secure Credential is specifically for retrieving stored credentials from Orchestrator or Windows Credential Manager. It does not allow the user to manually input a customer ID. Using it here would fail because the activity expects a credential asset name and returns a username/password pair, not a free-text identifier.

Configure the process to start in the user's session by setting the robot's 'Login to Console' to No.

Why it fails: The 'Login to Console' setting determines whether the robot logs into a console session. For attended automations, the robot should run in the user's existing session, not create a new console session. Setting 'Login to Console' to No typically means the robot will not create a console session, but this setting is more relevant for unattended robots. It does not directly enable user intervention.

Enable the 'User Intervention' property in the Process settings within Orchestrator.

Why it fails: There is no 'User Intervention' property in Orchestrator process settings. While Orchestrator can manage attended automations, the ability for a user to intervene is controlled locally via UiPath Assistant, not through a process-level setting. This option describes a non-existent feature and would not provide the required functionality.

Set the robot to run in a separate Windows session using a high-density robot.

Why it fails: High-density robots are designed for unattended scenarios where multiple robots run on the same machine in separate sessions. For an attended automation, the robot must run in the user's interactive session to interact with their desktop. Using a high-density robot would isolate the robot from the user, preventing the user from seeing or intervening in the process.

Message Box with the Buttons property set to YesNo and the result stored in a variable.

Why it fails: A Message Box does display buttons and can return which one was clicked, but it is primarily a notification dialog. For a decision that drives branching, the dedicated Input Dialog with a predefined choice set is the more appropriate and explicit construct. A Message Box can be made to work, yet it is not the activity the scenario is steering toward for capturing a structured Yes or No decision.

Form activity with a text field that the user fills in and submits.

Why it fails: A Form can absolutely collect structured input, but it is heavier than needed for a simple Yes or No confirmation and requires designing a form schema. The scenario asks for a quick blocking confirmation with two choices. While technically possible, a Form is overkill here and does not match the lightweight decision dialog the requirement describes.

Write Line activity with a prompt string and a variable to capture the response.

Why it fails: Write Line writes to the Output panel and does not interact with the user at all. It cannot display a dialog, cannot present Yes and No buttons, and cannot capture a click. This option confuses logging with user interaction and would leave the workflow with no way to obtain the confirmation the scenario requires.

Implement a global handler that catches the popup and uses a Wait Element Vanish activity to pause until the user logs in.

Why it fails: A global handler is for handling exceptions, not for routine UI events like a popup. While it could detect the popup, using it to pause and wait is not its intended purpose. It would complicate error handling and may not resume the main workflow correctly. This is not a recommended pattern for attended automation.

Configure the 'ContinueOnError' property of the form-filling activities to True and add a Delay after each field.

Why it fails: ContinueOnError would allow the robot to skip errors, but it would not pause for the user to log in. The robot would likely fail to fill fields correctly because the session is timed out. Adding delays does not solve the root issue and may cause the robot to proceed with invalid data. This approach does not handle the popup appropriately.

Use a Parallel activity with one branch waiting for the popup and another continuing the form filling.

Why it fails: A Parallel activity runs branches concurrently, which could lead to race conditions where the robot continues filling the form while the popup is present, causing errors. It does not inherently pause the main workflow. This approach is complex and error-prone for handling a blocking popup that requires user intervention.

Enable the "Login to Console" option.

Why it fails: The "Login to Console" option is used for Unattended robots to specify whether the robot should log in to the console session. For Attended robots, this setting is not applicable because the robot uses the already logged-in user session. Enabling it would not affect attended automation and is not required. The requirement is to handle the case where the user is not logged in, which is addressed by other settings.

Set the Robot's execution setting to "Only When User Is Logged In".

Why it fails: There is no such setting called "Only When User Is Logged In" in Orchestrator robot configuration. Attended robots inherently run only when the user is logged in and interact with the user session. The requirement to handle the case where the user is not logged in is not solved by a specific setting; rather, the automation simply cannot run. Therefore, this option is not a valid configuration.

Assign the robot to a user account that is always logged in.

Why it fails: While an attended robot requires a logged-in user session to run, it is not necessary for the user to be always logged in. The robot is triggered by the user, so if the user is not logged in, the automation cannot run. However, this is a runtime condition, not a configuration requirement. The question asks for required configurations in Orchestrator, and this is not a setting but an operational assumption.

Configure a global Windows hotkey in Task Scheduler to launch the UiPath Robot CLI every time the key combination is pressed.

Why it fails: Using Task Scheduler for global hotkeys bypasses the Assistant context and can lead to session separation issues or unexpected permission prompts. UiPath Assistant provides native hotkey management specifically designed for safe attended execution within the current active Windows user session context.

Instruct the user to open UiPath Assistant manually and click the Run button whenever the CRM requires data entry.

Why it fails: Manual navigation to the Assistant panel disrupts user workflow and introduces significant latency into business processes. Attended automations rely heavily on fast, ergonomic trigger mechanisms like shortcuts to ensure that human-robot collaboration remains efficient and practical.

Develop a background Windows service that listens for specific keystrokes and invokes the UiPath Robot via the Orchestrator API.

Why it fails: A background Windows service invoking the Robot through the Orchestrator API bypasses the attended user session, so it cannot capture the CRM context or run interactively without disruption. It suits unattended server automation, but attended keyboard-shortcut triggering requires UiPath Assistant's global shortcut or a trigger configured for the user's session.

Invoke Workflow File with isolated scope

Why it fails: Isolated scope isolates the workflow process but does not provide a mechanism for pausing execution based on human input. It is primarily used for managing memory and variable isolation between parent and child workflows rather than controlling the interaction flow between the robot and a human operator.

Parallel activity with a Timeout property

Why it fails: While a Parallel activity allows concurrent processing, using a timeout does not guarantee that the human has actually provided valid input. It merely forces the workflow to proceed after a duration, potentially leading to errors if the user has not finished their required data entry task.

Retry Scope with a fixed interval

Why it fails: Retry Scope is designed for handling transient technical exceptions by repeating activities. It does not pause for human input; rather, it attempts to resolve programmatic failures. Using it for human interaction would lead to repeated, confusing prompts appearing to the user during the retry process.

Use the Get Password activity to retrieve sensitive data from local variables

Why it fails: Storing sensitive data in local variables is insecure as they can be easily inspected during debugging or in the logs. Secure strings should be passed directly to secure input fields or handled through Orchestrator credentials rather than being stored in standard string variables within the project.

Store user passwords in a plain text configuration file for quick access

Why it fails: Storing passwords in plain text is a severe security violation that exposes credentials to anyone with read access to the file system. In an attended environment, the user should provide their own credentials dynamically, or they should be retrieved securely from the Orchestrator credential store.

Disable the Robot log output globally to prevent data leakage

Why it fails: Disabling logs globally makes troubleshooting impossible and violates audit requirements. Instead of disabling logging, developers should use the 'Private' property on specific activities that handle sensitive data to ensure those specific values are not recorded in the execution logs while keeping general logs active for monitoring.

The robot is in an offline state and cannot communicate with Orchestrator

Why it fails: If the robot were offline, it would fail to start or report a connectivity error immediately. The timeout behavior specifically indicates that the robot is active and waiting for a signal, but the configured duration for the interaction has been exceeded, causing the process to fail.

The LogToOrchestrator level is set to Information, causing a data overflow

Why it fails: Setting the log level to 'Information' controls the verbosity of logs sent to Orchestrator, but it does not affect the execution timing of activities or force a timeout. This setting impacts server load and log storage, not the runtime behavior of the robot's interaction with the user.

The AllowRemoteControl property is set to false, preventing user input

Why it fails: The 'AllowRemoteControl' setting determines if an administrator can take control of the robot session remotely. It does not govern the local input timeout duration of activities. Disabling this is a security measure and has no impact on the time allotted for local user interaction in workflows.

UiPath Orchestrator

Why it fails: Orchestrator is a management platform used for deployment, scheduling, and monitoring. While it can trigger jobs, attended automations are typically initiated by the end-user locally through the interface on their machine, rather than being centrally scheduled or managed as background tasks by the Orchestrator server platform.

UiPath Studio

Why it fails: Studio is the development environment used for building and testing workflows. While developers use it to run processes during testing, it is not the intended interface for end-users to trigger production attended automations. The Assistant is specifically designed for users to run and manage their workflows.

UiPath Robot Service

Why it fails: The Robot Service is a background process that manages the execution of workflows but does not provide a user interface. It works under the hood to execute instructions. Users interact with the Assistant, which then communicates with the Robot Service to launch the requested automation process.

Set the robot to run in an isolated session

Why it fails: Running in an isolated session (like a separate Windows user) is used for unattended robots to prevent interference. In an attended context, the robot must share the same session and desktop as the user, so an isolated session would prevent the robot from interacting with the user's active applications.

Always force the application to the foreground before interacting

Why it fails: Forcing an application to the foreground steals focus from the user, which is highly disruptive in an attended environment. If a user is typing in a document, the robot suddenly bringing another window to the front will interrupt their work, leading to poor user experience and potential errors.

Implement a global hotkey to pause the robot immediately

Why it fails: While a hotkey is a good feature for control, it is a reactive measure rather than a proactive strategy for preventing interference. Developers should design the automation to be non-intrusive by default, using background-friendly interaction methods, rather than relying on the user to manually intervene when interference occurs.

Use overly technical error messages to help users debug the process

Why it fails: Users do not need technical stack traces or raw error codes. Messages should be written in plain language that guides the user on how to resolve the issue, such as checking a specific field or restarting an application, rather than showing complex system information that causes unnecessary confusion.

Use modal windows that prevent interaction with the underlying application

Why it fails: Modal windows that lock the application can be problematic if the user needs to reference data from that application to fill out the form. While sometimes necessary, they should be used sparingly to avoid trapping the user and preventing them from performing necessary cross-reference tasks during the interaction.

Use image-based automation exclusively

Why it fails: Image-based automation is fragile and highly sensitive to resolution, theme changes, or minor visual shifts. It is the least reliable method for interacting with applications. It should only be used as a last resort when selectors cannot be identified, as it leads to high maintenance and frequent failures.

Restart the application at the start of every process run

Why it fails: Restarting the application is a heavy-handed approach that disrupts the user's session. If the user has unsaved data or is currently working in the app, forcing a restart would lead to data loss or user frustration. It is not an appropriate solution for selector instability in attended automation.

Rely on the UI Explorer to generate full selectors every time

Why it fails: Full selectors with exact attributes are brittle and break easily upon any UI change. Relying on them without optimization or anchor utilization leads to a fragile automation that requires constant manual updates by the developer whenever the application interface is modified, creating a high-maintenance and unreliable production process.

The selector is incorrect; use UI Explorer to update it

Why it fails: The error specifically mentions that the element is not in the foreground during a keystroke sequence, not that the element is missing. Updating the selector will not solve a focus conflict or concurrency issue where the robot and user are competing for the same interface element's active state.

The application is non-responsive; increase the TimeoutMS

Why it fails: Increasing the timeout would simply make the robot wait longer for an element that is already visible but cannot be clicked because of the focus conflict. The issue isn't timing out; it is the inability to perform the click action while the user is also interacting with the input.

Disable user interaction during the execution of the robot

Why it fails: Disabling the user's keyboard or mouse is a poor practice in attended automation, as it prevents the user from being productive. The purpose of an attended robot is to work alongside the human, and the developer should design the process to be non-intrusive rather than restricting the human operator.