Refer to the Exhibit Practice Questions

Use 'Read CSV' and map the columns directly to the 'Move File' input arguments.

Why it fails: The provided exhibit is in JSON format, not CSV. Attempting to use the 'Read CSV' activity will result in a parsing error or incorrectly mapped data. JSON structures have different hierarchy and syntax requirements compared to flat CSV files, necessitating the use of specialized JSON parsing activities to extract configuration values accurately for the workflow.

Use 'Read Text File' and regex extract the paths, then move the file.

Why it fails: Regex extraction is fragile and prone to failure if the JSON structure changes slightly. While possible, it is not the recommended approach when a dedicated 'Deserialize JSON' activity is available. Using structured parsing is safer and more maintainable, as it respects the JSON schema rather than relying on potentially unpredictable pattern-matching techniques.

Use 'Get Environment Variable' to read the JSON file contents.

Why it fails: Environment variables are designed for system-level settings, not for reading content from arbitrary JSON files. 'Get Environment Variable' will not retrieve the file content required to configure the automation. This approach is fundamentally incompatible with the requirement of reading data from a local JSON configuration file, leading to null or incorrect input data.

Manually delete the 'Custom_Utils' folder from the local NuGet cache directory.

Why it fails: Deleting files from the local NuGet cache does not address the dependency mismatch defined in the project.json file. The project will still demand version 1.0.2 and will fail when it cannot find it, or it will continue to conflict with the existing 1.0.3 version available.

Downgrade the library version 1.0.3 to 1.0.2 on the Orchestrator feed.

Why it fails: Downgrading a library can break other processes that already rely on version 1.0.3. NuGet feeds are designed to be additive; you should move forward by updating the process to use the newer library rather than rolling back libraries, which compromises the integrity of other dependent automations.

Rename the 'Custom_Utils' package file to 'Custom_Utils.1.0.2.nupkg' in the feed.

Why it fails: Renaming files in a NuGet feed manually violates the integrity of the NuGet package structure. The metadata inside the .nupkg file would not match the filename, leading to corrupted feeds and further runtime errors when Studio attempts to validate the package manifest during the installation process.

The project will publish, but only after showing a warning.

Why it fails: If 'Enforce' is true, the analyzer treats the violation as a hard error. It does not provide an option to bypass the block with a simple warning. Therefore, the project cannot be published while the violation exists. The 'Enforce' flag is specifically designed to prevent this behavior entirely.

The publication succeeds because ST-SEC-002 is not enforced.

Why it fails: While ST-SEC-002 might not be enforced, the project is still blocked by the enforced rule ST-NMG-001. A single enforced violation is enough to halt the entire publication process. It does not matter if other rules are not enforced; the presence of one blocker is all that is required.

The project publishes only the files without violations.

Why it fails: UiPath projects are published as a single package (NuGet file). You cannot selectively publish files or exclude parts of the project during the publication process. If the project contains a violation of an enforced rule, the entire project fails to publish, regardless of which files contain the violations.

Variables defined in parent sequences are automatically deleted after the first child sequence completes.

Why it fails: Variable lifecycles persist as long as the parent sequence is executing. They are not automatically deleted upon the completion of child sequences. The issue is strictly related to the visibility/scope definition and whether the variable was correctly initialized within the hierarchy to be visible to the specific target activity.

The variable 'InvoiceNumber' must be passed explicitly as an argument to every child sequence.

Why it fails: While passing data via arguments is a best practice for modularization and reusability, it is not strictly required for a variable to be accessible in a nested sequence. A variable defined in a parent scope is naturally accessible to all child activities, provided the scope was correctly set during creation.

The variable name is case-sensitive and does not match the declaration.

Why it fails: Variable names in UiPath are indeed case-sensitive; however, the error message indicates that the variable is 'not defined in the current scope,' which specifically points to a hierarchy or access issue rather than a simple naming convention mismatch, which would typically report a typo or identifier error instead.

The file is not in the correct folder.

Why it fails: If the file were not in the correct folder, the error would be 'FileNotFoundException', not an 'IOException' regarding a process lock. The current error explicitly states that the file is open and locked by another process, confirming that the path is correct but the file is currently inaccessible.

The Read Range activity is still running in the background.

Why it fails: Activities in UiPath are generally synchronous. The Read Range activity completes before the next activity starts, so it would not be actively running while the bot is trying to execute later steps. The lock is caused by the application process management, not by an individual activity remaining active.

The Send SMTP Mail Message activity is accessing the Excel file.

Why it fails: The Send SMTP Mail Message activity is entirely unrelated to Excel file handles. It manages network connections to mail servers. It cannot lock an Excel file, as it does not interact with the filesystem in a way that would trigger an IO lock on a spreadsheet file.

The rule is disabled, causing a syntax error in the analyzer.

Why it fails: The exhibit shows 'enabled' is set to true, which means the rule is actively scanning the project. If it were disabled, the analyzer would ignore the rule entirely. Therefore, a disabled rule cannot be the cause of a build failure related to active rule enforcement or project validation.

The analyzer rule is missing a scope parameter.

Why it fails: While specific rules have different parameters, the presence of 'enforce' and 'action' in the JSON represents a standard valid configuration. A missing scope parameter would not cause a build-time block in the manner described. The failure is due to the active enforcement policy violating the project's current state.

The rule is set to 'Warning' rather than 'Error'.

Why it fails: The 'action' field in the exhibit is explicitly set to 'Error'. If it were set to 'Warning', the project would typically still be allowed to publish, assuming other errors did not exist. The 'Error' status is the primary driver behind the immediate halt of the publishing process.

The item will be added successfully because the policy allows access to the Queue.

Why it fails: Access to a queue does not grant universal permission to perform all operations. The policy clearly limits the robot to viewing items and setting statuses. Adding an item is a separate action, and since 'AddQueueItem' is not listed in the 'Action' array, the operation will fail due to insufficient permission.

The request will succeed because the policy applies to the entire 'InvoiceQueue' resource.

Why it fails: While the policy correctly scopes the resource to the 'InvoiceQueue', the action-level permissions are restrictive. Resource-level access is not enough; the actions themselves must be explicitly permitted. Without the specific 'AddQueueItem' action, the robot lacks the authorization required to write new data into the queue, regardless of resource scope.

The robot will receive a 500 Internal Server Error.

Why it fails: A 500 Internal Server Error indicates a server-side failure or crash. Permission issues, such as those caused by a restrictive policy, trigger a 403 Forbidden error, which is the expected response when a client tries to perform an action they are not authorized to execute on a secured resource.

The State Machine restarts from the Initial state to attempt a retry.

Why it fails: State Machines do not restart automatically unless a transition is explicitly drawn from the 'ProcessData' state back to the 'Initial' state. In the exhibit, the 'Error' transition leads directly to the 'FinalState'. Automated retries must be programmatically defined by the developer through transition logic; otherwise, the state machine follows the defined path to termination.

The State Machine enters a suspended state until the error is manually cleared.

Why it fails: UiPath State Machines are designed for automated execution and do not enter a 'suspended' state on their own. If an error occurs and a transition handles it, the machine follows that transition. If an error occurs that is NOT handled by a transition or a Try Catch, the entire workflow would fail, rather than pausing for manual intervention.

The 'ProcessData' state's Entry activities are re-executed before transitioning.

Why it fails: Entry activities only run when a state is entered. If a transition is triggered to leave 'ProcessData', those entry activities are not run again. The machine would only re-run 'ProcessData' entry activities if a transition pointed back to 'ProcessData' itself (a self-transition), which is not what occurs when the 'Error' transition to 'FinalState' is triggered.

The Scale parameter is set incorrectly.

Why it fails: The Scale parameter affects image processing quality but does not trigger engine-level exceptions. An incorrect scale might result in poor text recognition quality or garbled output, but it will not prevent the engine from being located or initialized within the automation runtime environment.

The Range is invalid for the document.

Why it fails: Invalid ranges typically result in execution exceptions related to index bounds or page numbers. They do not trigger system-level errors regarding the existence of the OCR engine itself. The error log specifically identifies the engine as the culprit, pointing away from document-specific content errors.

The Language parameter is unsupported.

Why it fails: Unsupported languages would result in character errors or gibberish output rather than a failure to find the OCR engine. The error message is very specific about the engine being missing, meaning the system cannot even instantiate the object required to begin processing the English language data.

The data will be recorded but truncated to 100MB

Why it fails: The 'MaxLogFileSizeMB' setting governs the total file size of log storage, not the content of individual messages. Furthermore, the 'EnableVerboseLogging' setting acts as a filter; if it is set to false, verbose messages are not processed or written to the logs at all, regardless of size constraints.

The robot will throw a policy exception and stop

Why it fails: Attempting to log at a prohibited level does not trigger a runtime exception. The robot simply ignores the instruction to log the verbose message. It continues the execution flow normally, as logging is an auxiliary activity to the main business process logic and should not interrupt operations.

The logs will be saved to a local file instead of Orchestrator

Why it fails: The logging configuration defines the behavior of the engine, not the destination of the logs. Disabling verbose logging means the data is not captured at all; it does not redirect the output to a local disk. The system respects the policy filter across all potential storage locations.

Increase the timeout property on the Move File activity to 60 seconds.

Why it fails: The Move File activity does not have a timeout property that makes it wait for file availability. It performs an immediate operation. If the file is locked, the activity will immediately throw an exception. Simply increasing settings on the activity itself will not resolve the underlying file lock issue.

Use the Kill Process activity to force close all applications before moving the file.

Why it fails: While this might solve the lock, it is an aggressive approach that could cause data loss in other applications. Killing processes blindly without checking if they are currently working on the specific file is poor practice and can lead to unstable system states or loss of unsaved user data.

Change the file extension to .tmp before moving it, then rename it.

Why it fails: Renaming a file that is currently locked by another process will result in the same IOException. The OS prevents any modification or movement of a file while an application has an open handle to it. This approach does not bypass the underlying file system lock enforced by the operating system.

The library package was corrupted during the upload to Orchestrator.

Why it fails: Corrupted packages would typically cause installation errors or assembly load exceptions, not a runtime null reference exception within the activity logic. The error message indicates the activity is executing successfully but failing internally due to a logic flaw regarding object initialization, not a package transport issue.

The project is using an incompatible version of the .NET framework.

Why it fails: Incompatibility with the .NET framework would manifest as a TypeLoadException or a version mismatch error at compile time or execution start. A null reference exception is a logic error that occurs when the code runs, meaning the environment is likely compatible, but the code logic is flawed.

The Git repository history is causing an invalid library compilation.

Why it fails: Git history affects version control, not the execution logic of compiled C# code. If the code compiles and the package is published, the logic remains the same regardless of how many commits are in the repository. The issue resides in the code's handling of data, not the source control.

Change the Port to 25 and set EnableSSL to False.

Why it fails: Port 25 is typically blocked by modern security policies and is not encrypted. Disabling SSL on a modern SMTP server like Office 365 will cause the connection to be rejected immediately by the server, resulting in an authentication error rather than a timeout during the transmission process.

The server address is incorrect and should be set to pop.outlook.com.

Why it fails: POP is a protocol used for receiving emails, not sending them. Sending emails requires an SMTP protocol address. Changing the server to a POP address would result in a connection failure or an 'invalid protocol' error, not a timeout occurring specifically during the attachment upload process.

The error is caused by an invalid sender email address format.

Why it fails: An invalid sender address format would trigger a '550' or 'Sender rejected' error from the SMTP server immediately upon submission. It would not cause a timeout error, which is specifically related to the network latency or the time taken to upload the payload of the message.

The Robot machine is disconnected from the Orchestrator URL.

Why it fails: A disconnection between the Robot machine and Orchestrator would typically result in a 'Connection Timeout' or 'Service Unavailable' error, rather than a 403 Forbidden status. The 403 status specifically points to a logical permission issue rather than a physical or network connectivity failure between the agent and the server.

The Queue item has already been locked by another robot instance.

Why it fails: When a queue item is locked by another robot, Orchestrator typically returns a conflict or a 'Busy' response, not a 403 Forbidden error. This error is strictly related to authorization and role assignments, indicating that the system knows who the requester is but forbids them from accessing the specific data.

The license for the Orchestrator tenant has expired.

Why it fails: An expired license would typically prevent the robot from connecting to the Orchestrator at all or cause a broad service-wide failure, rather than a specific access-denied error for a queue resource. The 403 Forbidden error is a precise indicator of insufficient permissions assigned to the specific user or robot entity.

Use 'Get Text' activity with 'data.id' as the selector.

Why it fails: Get Text is a UI Automation activity used for interacting with browser elements or desktop windows. It cannot parse or manipulate raw JSON response strings returned from web services. It requires a valid UI selector to function, which is not applicable when dealing with raw data structures like JSON objects.

Use 'Assign' activity to read the response string directly using string splitting.

Why it fails: String splitting is highly fragile and prone to errors if the JSON format changes slightly, such as whitespace variations or key ordering. It does not parse the underlying data structure correctly. Using formal JSON parsing activities ensures the automation remains resilient to minor formatting changes in the API response.

Use 'Deserialize JSON Array' to extract the 'id' field.

Why it fails: Deserialize JSON Array is specifically for parsing JSON structures that start with square brackets, indicating a list of items. Since the exhibit shows a JSON object starting with curly braces, this activity will throw an invalid cast exception during execution because it expects an array type instead of an object.