UiPath RPA Interview Questions & Answers

Projects panel, Activities panel, Workflow Designer, Properties panel, Outline panel, Variables panel, Arguments panel, Imports panel and the Output panel.

It holds every activity available to the project, grouped by category and searchable. Activities are dragged from here into the Designer. If an activity is missing, the package that contains it has not been installed through Manage Packages.

It exposes the configuration of the currently selected activity: input, output, timeout, delay before and after, continue on error, and display name. Most runtime behaviour is controlled here rather than in the Designer.

Log messages, Write Line output, exception detail and execution timing. It is the first place to look when a run behaves unexpectedly, and it shows how long each part of the process took.

The Output panel shows what happened during execution. The Outline panel shows the structure of the workflow, the nesting of activities and the variables in scope. One is runtime, the other is design time.

Sequence, for small linear tasks. Flowchart, for branching business logic. State Machine, for large transactional projects driven by conditions. Global Exception Handler, a workflow that defines project behaviour when an unhandled error is thrown. Only one Global Exception Handler is allowed per project.

A Sequence is a linear container. Activities execute top to bottom in order. It is the right choice for a small, self contained block of steps such as filling one form, and it is reusable inside larger workflows.

A Flowchart is a non linear container built from a Start node and connectors. It supports branching through Flow Decision and Flow Switch and allows you to loop back to an earlier node. It suits end to end business logic where the path is not fixed.

Drag it from the Activities panel into the Designer, or double click it while the target container is selected, which places it inside that container.

The activity displays a red exclamation icon and the Design ribbon shows an error count. Hovering over the icon gives the reason, most often a mandatory property left empty or a variable that is out of scope. The project will not run until the count is zero.

Save to a partition other than C:, such as D: or E:, using the Browse option when creating the project. Desktop, Downloads and C: are formatted during a Windows reinstall and are the most common cause of lost work. On a team project the folder should sit under source control.

Manage Packages is where activity packages, libraries and dependencies are searched, installed, updated and removed. It also shows what is already installed for the current project. Packages such as UiPath.PDF.Activities, UiPath.Database.Activities and UiPath.IntelligentOCR.Activities are installed from here.

VB.NET and C# are supported for expressions. Through Invoke Code you can execute VB.NET or C#, and through the Python activities package you can call Python. Invoke VBA is available for Excel macros.

Studio creates a project folder containing project.json, which stores the project name, description, dependencies and entry point, and Main.xaml as the default entry workflow. Any package you install is recorded as a dependency in project.json.

The description carries into project.json and into Orchestrator after publishing. On a tenant with fifty processes the description is often the only way a support engineer can tell them apart at 2am. It costs ten seconds and it is skipped constantly.

Message Box displays a value to the user and halts execution until the box is dismissed. The text property expects a String, so a static message must be wrapped in double quotes and any non string variable must be converted with .ToString.

Message Box waits for a human to click OK. On an unattended robot nobody clicks, so the job hangs until it times out. Use Log Message during development and in production instead, which writes to the Output panel and to Orchestrator without blocking execution.

GenericValue when created from the Variables panel. It accepts almost anything, which is convenient and dangerous, because it defers the type error to runtime instead of raising it at design time.

GenericValue can hold a String, number, date or array and converts implicitly depending on how it is used. It is useful for quick work and a liability in production, because 5 + 5 may produce 10 or 55 depending on what the runtime decides the values are.

A String stores text and is not valid for arithmetic. An Int32 stores a whole number and supports arithmetic. "5" and 5 are different values with different behaviour.

They concatenate. "5" + "5" produces "55", not 10. This is the single most common beginner error in UiPath. Convert first with Convert.ToInt32 or CInt.

Convert.ToInt32(strValue), or CInt(strValue). For decimals use Convert.ToDouble. If the string may contain non numeric characters, use Int32.TryParse so a bad value returns false instead of throwing.

Message Box, Log Message and Write Line expect a String. An Int32 or Double passed directly raises a compile error. intCount.ToString converts it.

An Array stores multiple values of the same type with a fixed length set at declaration. A List stores values of the same type with no fixed length, so items can be added and removed at runtime. An Enumeration is a fixed set of named constants.

Scope defines where a variable is visible. A variable declared inside a Sequence exists only within that Sequence and its children. Outside it, the variable does not exist.

Open the Variables panel, find the variable and change the Scope column to a parent container that covers both sequences. Do not create a second variable with the same name, which is the usual reflex and produces two unrelated variables.

Arguments pass data between workflow files. They have a direction and are defined in the Arguments panel of the workflow that receives or returns them.

A variable is internal to one .xaml file. An argument crosses the boundary between .xaml files. You cannot read a variable from another workflow, which is exactly why arguments exist.

In, which passes a value into the workflow. Out, which returns a value from it. In/Out, which does both. Property, used when building libraries and reusable components.

When the called workflow must receive a value, modify it, and return the modified value. A running counter or a DataTable that is appended to inside a sub workflow are typical cases.

In. If you create an argument to return a result and forget to change the direction, the caller receives nothing and the value silently disappears.

It calls one .xaml from another. The Import Arguments button maps the caller's variables to the called workflow's arguments. It is the basis of modular design in UiPath.

In Invoke Workflow File, click Import Arguments. The panel lists every argument defined in the target workflow with its direction. Map each one to a variable of a matching type in the calling workflow.

Reopen Import Arguments in the Invoke Workflow File activity and refresh the mapping. New arguments do not appear automatically in a caller that was configured earlier, and the invoke will fail validation or pass a null.

Each workflow becomes independently testable, reusable across projects and safe for two developers to work on at once. It also makes support cheaper, because a defect is isolated to one file rather than a single 400 activity Main.

Assign sets a variable or argument to a value or an expression. It is used for arithmetic, string manipulation, type conversion and moving values between variables.

Flow Switch is the Flowchart specific version of Switch. It splits the control flow into multiple branches and executes exactly one based on the evaluated expression. Each branch is a Flow Step.

While, Do While, For Each and For Each Row in Data Table. Parallel For Each exists for asynchronous iteration.

While evaluates the condition before each iteration and runs the body only while the condition is true. If the condition is false at the start, the body never executes.

Do While runs the body first and evaluates the condition afterwards. The body is therefore guaranteed to execute at least once, even if the condition is false from the start.

Condition placement. While checks first, so zero iterations are possible. Do While checks last, so the minimum is one iteration. Choose Do While when the action must happen at least once, such as attempting a login before checking whether it succeeded.

For Each iterates through a collection: an array, a list, a collection of mail messages, or any IEnumerable. The TypeArgument property must match the type of the items, or the loop throws at runtime.

Whenever you are iterating a DataTable. For Each Row handles the row pointer and the end condition for you. A While loop over a DataTable requires a manual counter, a manual increment and a manual bounds check, and the missing increment is the classic infinite loop.

CurrentRow("ColumnName").ToString, or CurrentRow(0).ToString by index. Referencing by name is preferred, because column order changes and column names usually do not.

The run throws "Column name does not belong to the table". The match is exact, so a trailing space or a case difference in the header is enough to break it. Check the header cell, not the expression.

Break exits the current loop immediately and continues with the activity after it. It is used when the item you were looking for has been found and further iteration is pointless.

Declare an Int32 with scope covering the loop and a default of 0, then use an Assign inside the body: intCounter = intCounter + 1. Place the Assign so it runs on every path, otherwise a While loop that skips it never terminates.

Validate the input after the Input Dialog. If it fails, use a Flow Decision to route back to the Input Dialog node rather than terminating. Keep a retry counter so a user who never enters a valid value does not loop forever.

It never executes. Studio does not raise an error, because an unconnected node is valid. The process simply runs and skips the logic, which is why an orphaned node is harder to spot than a broken expression.

A year is a leap year if it is divisible by 4 and not by 100, or if it is divisible by 400. As an expression: (intYear Mod 4 = 0 And intYear Mod 100 <> 0) Or (intYear Mod 400 = 0). 2000 is a leap year, 1900 is not, and candidates who forget the 400 rule get caught on exactly that example.

Delay pauses execution for a specified duration. It is also available on any activity through the Delay Before and Delay After properties.

Delay Before pauses before the activity executes. Delay After pauses after it completes. Both are measured in milliseconds and both are a last resort. A hard coded delay either wastes time or is too short on a slow day. Prefer Element Exists or a Wait activity that reacts to the actual application state.

They pad every run with fixed dead time and they do not adapt. A process with forty Delay activities of 3 seconds each burns two minutes per transaction, and multiplied by a thousand transactions that is a licence you did not need to buy. They also mask the real problem, which is usually a missing wait condition.

Asterisk (*) replaces zero or more characters. Question mark (?) replaces exactly one character. They are used to absorb the part of an attribute that changes between runs.

When a value inside an attribute changes but a stable pattern remains. A title of "Invoice 4471 - Processing" becomes 'Invoice * - Processing'. Do not wildcard so broadly that the selector matches several elements, because the robot then picks the first match and the failure looks random.

A dynamic selector uses a variable or argument inside an attribute instead of a fixed value, so the same activity can target a different element on each iteration. It is written as "<webctrl name='" + strItem + "' tag='INPUT' />".

Open the Target section of the activity, switch the Strict Selector or Fuzzy Selector field to expression mode, and concatenate the variable into the string. The selector is a String, so ordinary concatenation rules apply and any non string variable needs .ToString.

A Strict Selector demands an exact attribute match and fails the moment anything changes. A Fuzzy Selector matches approximately using a similarity threshold, so it tolerates small variations in text. Modern activities can use both together along with an image, and will fall back across them.

An anchor is a stable nearby element used to locate an unstable target. Instead of identifying a text box by its own attributes, the robot finds the label next to it and works outward from there.

Pick something that does not move relative to the target and does not appear more than once on screen. A field label is a good anchor. A generic word like "Submit" or a heading that repeats in a table is a bad one, because the anchor becomes as ambiguous as the target.

Element Exists checks whether an element is present and returns a Boolean. It does not throw when the element is missing, which is what makes it the right tool for testing whether a pop up appeared.

Element Exists defaults to 30 seconds. When you are checking for an error pop up that only appears occasionally, the happy path pays that 30 seconds on every single transaction. Drop it to 2 or 3 seconds. On a thousand transactions that is eight hours of runtime removed.

30000 milliseconds, which is 30 seconds. After that the activity throws a selector not found exception.

Open the activity, use Repair or Indicate in the Target section and re-indicate the element on screen. Then compare the new selector with the old one in UI Explorer to see which attribute changed. Fix that attribute with a wildcard or a variable rather than accepting the regenerated selector wholesale, or you will be repairing it again next release.

Use Validate or Highlight in UI Explorer to confirm the selector resolves to exactly one element, then close and reopen the application and validate again. A selector that only works on the currently open instance is a selector that works once.

Use Application/Browser is the Modern container. It opens or attaches to the target application, supplies the window context for every partial selector inside it, and controls whether the application is opened and closed by the robot.

Open set to Always so the application is launched, Close set to Never so it stays open for the following states, and Resize Window set to Maximize. In later states, Open is set to Never so the robot attaches to the running instance instead of launching a second one.

Selector and image resolution depend on the rendered layout. A restored window on a development laptop and a maximised window on a production VM produce different element positions, and image based steps fail. Maximising makes the layout deterministic across machines.

They must sit inside a container such as Use Application/Browser, because they use partial selectors and depend on the container for the window context. Placed outside it, they either fail validation or find the wrong window when two instances are open.

Stop relying on position. Anchor each field to its label with Anchor Base or the Modern anchor option so the target is resolved relative to text that moves with it. If the field itself has a stable attribute such as aaname or id, use that instead and ignore layout altogether.

Wildcard the changing portion. "Report - 14:32:07" becomes 'Report - *'. If the whole title is volatile, drop the title attribute and identify the window on a stable attribute such as the process name or class.

Try Simulate Type first, then Send Window Messages, then Default with ClickBeforeTyping enabled. Some custom controls only respond to real keystrokes, in which case use Send Hotkey or Type Into with SendWindowMessages off. If nothing lands, set the value through the application's API or database instead of the UI.

Install the UiPath extension for that browser from Studio, under Tools, and enable it in the browser's extension settings. In Chrome it must also be allowed in Incognito if the process runs there. On a locked down machine the extension needs admin rights, which is the usual blocker.

Select Item only works on true HTML select or combo box controls. Modern web frameworks render a fake dropdown from div elements, which is not a select. Click the control to open it and then Click the option, or set the underlying input directly.

Fewer activities to configure, one container instead of several, resilience through multiple targeting methods, and lower maintenance when applications change. New Studio projects default to Modern, and Classic is now an opt in compatibility mode.

Verify Execution checks after the action whether the expected outcome occurred, for example that the typed text is present in the field, and retries or throws if not. It removes the pattern of typing and then adding a separate Get Text to confirm.

The activity retries for the configured duration and then throws. The usual cause is not a broken selector but the application reformatting the input, for example stripping spaces from a phone number or reformatting a date. Verify against what the field actually displays after entry, not against what you typed.

It replaces the old chain of Open Browser and Attach Browser plus separate containers. One activity opens or attaches, sets the window state, supplies the container for every child selector and controls the close behaviour.

Initialisation, where applications open and configuration loads. Processing, where the business logic runs per transaction. End or Closing, where applications are closed, results are written and the run is logged.

Default, which is the slowest, cannot run in the background, and supports hotkeys. Send Window Messages, which runs in the background and supports hotkeys. Simulate Type or Simulate Click, which is the fastest, runs in the background, and works with most web and desktop applications but not all custom controls.

Full Text, the default, fastest, works in the background, extracts hidden text, cannot return screen coordinates, and works only with desktop applications. Native, which is accurate, returns text position, cannot extract hidden text, and does not support background execution or Citrix. OCR, which is the least accurate but is the only option where the other two return nothing, including Citrix.

OCR. Full Text and Native both depend on the application exposing text through its UI framework, and a Citrix session exposes pixels only. OCR is slower and imperfect, so pair it with validation on the extracted value.

Get Text in the Modern experience, or Get Full Text and Get Visible Text in Classic. All return a String.

Inside a container such as Use Application/Browser, because it uses a partial selector and needs the window context from the container.

Save with a unique file name rather than a fixed one. Append a timestamp with DateTime.Now.ToString("yyyyMMdd_HHmmss"), or append the transaction reference. Writing to the same path on every capture leaves you with one screenshot and no evidence of the other forty failures.

Do not restart the recording. Finish the session, then delete or re-indicate the incorrect activity in the generated workflow. Recorder output is normal, editable activities, not a locked script.

Every stray click and focus event becomes an activity, which slows the run and creates selectors that will break for no business reason. Always prune the generated workflow. Recorder output is a first draft, not a deliverable.

The recorder sets Open and Close to Always by default, so every recorded block relaunches the application. Change Open to Never where the application is already running from a previous state, and Close to Never anywhere except the final closing workflow.

Computer Vision lets the robot identify elements the way a person does, by looking at the screen, using a combination of AI, OCR and fuzzy text matching. It does not depend on selectors, which is why it works in Citrix, VDI and mainframe sessions.

It sends a screenshot to a CV model that detects controls such as text boxes, buttons and checkboxes, and runs OCR to read the text. The robot then acts on the identified control by its type and nearby text rather than by an attribute.

When the application exposes no usable attributes: Citrix, VDI, remote desktop, mainframe emulators, and some Java or legacy thick clients. If selectors are available, use selectors. CV is the fallback, not the default.

Because it converts a thin client problem into a thick client problem. With the robot inside the session, the applications expose their attributes normally and you get ordinary selector automation, full background execution and far lower maintenance. It usually needs a licence conversation and a client security approval, which is why teams skip it and then spend months maintaining image based steps.

Foreground automation. The robot must see the screen, so the session cannot be locked or minimised, and it cannot run in the background alongside other work on the same machine.

Image based and CV steps fail or click the wrong location, because the stored image and the coordinates no longer correspond to what is rendered. Standardise resolution and scaling across development and production VMs, and set it explicitly in the runtime settings. The RE Framework logs the resolution at Init for exactly this reason.

UiPath holds SOC 2 Type II and ISO 27001 certification, supports GDPR and HIPAA aligned deployments, encrypts Orchestrator credentials with AES 256, and integrates with enterprise credential stores such as CyberArk and Azure Key Vault.

Establish what is actually being blocked. Often the objection is to the full Studio install rather than to the robot. Offer the robot only, in a locked down service account, with the Orchestrator connection restricted to their network. If that is refused, price the CV based approach honestly, including the higher maintenance and the foreground only constraint, so the client is choosing the cost with their eyes open rather than discovering it in month three.

Read Range reads a block of cells into a DataTable. Read Cell reads a single cell into a value. Read CSV reads a CSV file into a DataTable. Write Range writes a DataTable into a sheet. Write Cell writes one value to one cell. Write CSV writes a DataTable to a CSV file.

DataTable. A single row is a DataRow, and a single cell is accessed from a DataRow by column name or index.

It defaults to A1 and overwrites whatever is already there, including headers and any prior results. On a results file this silently destroys the previous run's output.

AddHeaders on the Write Range activity. Without it the DataTable's column names are dropped and the sheet arrives as unlabelled data.

Append Range writes a DataTable below the last populated row of an existing sheet without overwriting existing data. It is the correct activity for accumulating results across runs.

Build Data Table creates an empty DataTable in memory with a defined column structure. It is used when the process needs an output table that does not come from a file.

It creates a fresh empty table every time it runs. Placed inside a loop it wipes the accumulated rows on every iteration and the file ends up with one row. It belongs in Init, outside the loop.

Add Data Row. Pass the values through the ArrayRow property as {value1, value2, value3}, or pass a DataRow through the DataRow property.

Curly braces with comma separated values: {strName, intAge.ToString, strStatus}. The order must match the column order in the DataTable, and each value must be compatible with its column's type.

Add Data Column, specifying the column name and type against the target DataTable. It is useful when the output structure depends on what was read, and it avoids maintaining a Build Data Table definition that has to be edited every time a field is added.

Read the input file into a DataTable, use Add Data Column to add the result columns, populate them as you process each row, then Write Range the whole table once at the end. You keep the input context alongside the result and you touch the file once instead of on every iteration.

Use Execute Macro, or Invoke VBA to run VBA code held in a separate file. Both require Excel installed, so they are Excel activities, not Workbook activities.

Supply the password in the Password property of the Excel Application Scope or the Workbook activity. Never hard code it. Store it as a Credential asset in Orchestrator and fetch it with Get Credential at runtime.

Filter Data Table applies the condition to the whole table in one operation. A loop with an If inside iterates every row and evaluates the condition one at a time. On a hundred rows the difference is invisible. On a hundred thousand it is minutes against hours.

It removes rows where every column matches an earlier row, returning a clean DataTable. It is used at the loading stage so the same transaction is not queued twice, which is cheaper than detecting the duplicate after the bot has already submitted it.

Stop using Read Range and treat the workbook as a database. Add UiPath.Database.Activities, then Connect to Database with the OLEDB provider: "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" & ExcelPath & ";Extended Properties='Excel 12.0 Xml;HDR=YES;IMEX=1';". Run a SQL query against the sheet and pull only the rows and columns you need. Reading the whole table into memory and then filtering it is what is actually costing the time.

Because it lets you filter, join and aggregate at the query level instead of loading everything into memory. On a large workbook it turns a full table read plus a loop into a single targeted query, and it removes the Excel install dependency.

Treat the sheet name as a table with a dollar sign in brackets: SELECT * FROM [Sheet1$] WHERE Status = 'Pending'. The header row supplies the column names when HDR=YES is set in the connection string.

Read once into a DataTable instead of reading inside the loop. Replace per row Write Cell with a single Write Range at the end. Use Filter Data Table instead of an If inside the loop. If it is still slow, move to the OLEDB approach and query only what you need. In almost every case the bottleneck is file I/O inside the loop, not the loop itself.

Both retrieve mail. IMAP leaves messages on the server and syncs folders and read state. POP3 downloads messages and traditionally removes them from the server, so it does not stay in sync across clients. IMAP is the correct default for a bot that must not disturb a shared mailbox.

Outlook: Get Outlook Mail Message, Send Outlook Mail Message. Exchange: Get Exchange Mail Message, Send Exchange Mail Message. Gmail and generic servers: Get IMAP Mail Message, Get POP3 Mail Message, Send SMTP Mail Message. IBM Notes: Get IBM Notes Mail Message, Send IBM Notes Mail Message.

No. It uses the Outlook profile already configured and signed in on that machine. That is its advantage and also its dependency, because it fails on any machine where Outlook is not installed and configured.

Outlook is installed but no profile is configured, or the profile belongs to a different Windows user than the robot's service account, or Outlook is not running and the process has no session. On an unattended VM this shows up as "no Outlook session". Either configure the profile under the robot's account or switch to SMTP, which does not depend on a local client.

List<MailMessage>. It is iterated with a For Each where the TypeArgument is set to MailMessage.

For Each, with TypeArgument set to System.Net.Mail.MailMessage. Leaving the TypeArgument as Object is the usual cause of the error thrown on the first iteration.

Inside the For Each, reference CurrentItem.Subject and CurrentItem.Body. Both return a String. Headers such as From are read with CurrentItem.From.Address.

Set the Top property. Get IMAP Mail Message and Get Outlook Mail Message both default to 30. On a mailbox with thousands of messages, leaving it unbounded makes the retrieval itself the slowest part of the run.

OnlyUnreadMessages. Pair it with MarkAsRead so a message is not picked up again on the next run. Without MarkAsRead the bot reprocesses the same emails on every cycle.

Two ways. Use the Filter property on the Get activity, which filters at the server and is far faster. Or retrieve messages and apply an If inside the For Each, which is more flexible but pulls everything down first. Filter at source wherever the syntax allows it.

Use the Filter property on Get Outlook Mail Message with a DASL query such as "@SQL=""urn:schemas:httpmail:subject"" like '%Invoice%'", or apply an If on CurrentItem.Subject.Contains("Invoice") inside the loop. Filtering first means you are not saving attachments from every message in the mailbox.

Save Attachments, passing the MailMessage and a destination folder. The Filter property restricts which attachments are saved.

Set the Filter property to a wildcard pattern such as "*.pdf". Without it, every attachment including signature images and disclaimers is written to disk, and the process then tries to read a logo as an invoice.

Host smtp.gmail.com, port 587 with TLS enabled. Port 465 is used for SSL.

IMAP host imap.gmail.com, port 993. POP3 host pop.gmail.com, port 995. Both require SSL.

Google blocks plain username and password sign in from applications. With two step verification enabled you generate a 16 character App Password in the Google account security settings and use that in place of the account password. Without it, the IMAP or SMTP activity fails to authenticate no matter how correct the credentials look.

Set the Account property on the Outlook activity to the target account's email address. Left empty, it uses the default profile, which on a shared VM is often not the account the process is supposed to use.

Almost always the TypeArgument on the For Each is still Object instead of System.Net.Mail.MailMessage, so CurrentItem exposes no mail properties. The second candidate is an undisclosed recipient or a message with a null field that the expression does not guard against.

Filter at the server with the Filter property, not in the loop. Set OnlyUnreadMessages with MarkAsRead so each message is handled once. Set Top to a sensible batch size and let the process run more often rather than pulling everything at once. Move processed mail into a subfolder so the working set stays small permanently.

Read PDF Text for native PDFs. Read PDF with OCR for scanned or image PDFs. Both return a String.

Tesseract OCR and Microsoft OCR are included and free. UiPath Document OCR and UiPath Screen OCR ship with the platform. Google Cloud Vision OCR, Microsoft Azure Computer Vision OCR, ABBYY FineReader and OmniPage are paid or require a separate licence and key.

Tesseract and Microsoft OCR are free and available by default. Google Cloud Vision, Azure Computer Vision, ABBYY and OmniPage are paid and require an API key or a licence.

Because accuracy is document dependent. Tesseract handles clean printed text well and struggles with tables and poor scans. Microsoft OCR handles some layouts better. ABBYY and Google generally win on degraded or handwritten input. There is no universally best engine, which is why the platform ships several.

Scan resolution, ideally 300 DPI or better. Skew and rotation. Contrast and background noise. Font and font size. Language pack. Whether the content is handwritten. Tables and multi column layouts. Most accuracy complaints trace back to the source scan, not the engine.

Drop in the activity, set the file path, then drag the chosen OCR engine into the OCR scope inside it. Set the Scale property, usually between 1 and 3, to enlarge the image before recognition. Set the language. Assign the output to a String.

Split the text on a stable delimiter and index into the result, or use a regular expression with System.Text.RegularExpressions.Regex.Match. Anchor on a label that always precedes the value, such as "Invoice No:", rather than on a character position, because position moves the moment the layout changes.

Split breaks a String into an array using a delimiter and returns the parts. strText.Split("-"c)(1) takes the second segment. The index is zero based, so the first segment is (0).

Do not split on the value itself. Anchor on the fixed label that precedes it and take what follows, then parse with DateTime.ParseExact and the exact format string. Trying to match the date pattern directly breaks the first time the document uses a different format.

Cost and control. Document Understanding consumes licence units per page and needs the IntelligentOCR stack. A Python script using a PDF library, called through the Python activities, has no per page cost and gives full control over parsing. It is the right trade for high volume, stable format documents. Document Understanding earns its cost where formats vary and no rule survives contact with the next vendor.

Document Understanding is the framework for processing documents whose layout is not fixed. It digitises the document, classifies its type, extracts fields with rule based or ML models, allows human validation of low confidence results, and exports structured data.

UiPath.IntelligentOCR.Activities. UiPath.DocumentUnderstanding.ML.Activities is added for ML extractors.

Taxonomy Manager is where you define the document types the project will handle, grouped by category, and the fields to extract from each. It is project specific and opens from the Studio ribbon once IntelligentOCR is installed.

Digitize Document converts the file into machine readable form, producing the Document Object Model and the document text. Native PDFs are read directly, scanned files go through the OCR engine placed inside the activity.

Digitize Document detects whether a text layer exists. If it does, it reads it directly and the OCR engine is not used. If not, it routes the page through the configured OCR engine. This is why the OCR engine is optional inside Digitize Document but essential for scanned input.

Classify Document Scope determines which document type each file or page range belongs to, according to the taxonomy. It accepts one or more classifiers and passes the necessary parameters to them.

A classifier identifies the document type so the right extractor is used. Keyword Based Classifier matches repeatable titles or words. Intelligent Keyword Classifier also splits a multi document package into individual documents. FlexiCapture Classifier uses ABBYY FlexiCapture definitions. Machine Learning Classifier uses a trained model.

Data Extraction Scope is the container where extractors run. It takes the taxonomy, the document text and the classification result, and outputs an ExtractionResult containing every field the configured extractors could find.

RegEx Based Extractor, which uses regular expressions. Form Extractor, which uses templates and rules and suits structured forms, tables and checkboxes. Intelligent Form Extractor, which adds handwriting recognition to the Form Extractor. ML Extractor, trained models for invoices, receipts and purchase orders, which handle semi structured documents.

Form Extractor matches a document against a stored template and pulls fields from defined positions. It is the right choice for fixed layout forms, government documents and identity cards, where every instance looks the same. It is the wrong choice for invoices from forty different suppliers.

The matching elements are how the extractor recognises the template at runtime. With too few, a similar looking document from another vendor matches the wrong template and returns confidently wrong values. Five stable anchors spread across the page is the practical minimum.

A value between 0 and 1 indicating how certain the extractor is about a field. It drives the routing decision: above the threshold the value is accepted automatically, below it the document is sent to a human.

Present Validation Station opens the Validation Station so a human can review and correct the classification and extraction results. It supports create, read, update and delete on the extracted data and returns the corrected result to the process.

Poor scan quality, which no model fixes. Layout drift when a supplier changes their template. Multi page packages that need splitting before classification. Confidence thresholds set too high, which floods the validation queue, or too low, which lets bad data through. And the licence cost, which is per page and adds up quickly at volume.

Separate the problem by document type first. Classify properly so each vendor's layout goes to the right extractor rather than one generic template trying to cover everything. Use ML extractors for the semi structured majority and templates only for the genuinely fixed layouts. Then tune the confidence threshold per field, not globally, because an invoice number needs a higher bar than a supplier address. Retrain on the documents that failed, not on the ones that passed.

DataTable. It is then iterated with For Each Row in the same way as data read from Excel.

Statements that change data but do not return rows: INSERT, UPDATE, DELETE and DDL. It returns the number of affected rows as an Int32, which is worth checking rather than assuming the statement worked.

It releases the connection. Left open, connections accumulate across runs and eventually exhaust the connection pool, which fails a process that has nothing wrong with its logic. Put Disconnect in a Finally block so it runs even when the query throws.

Open SQL Server Management Studio and read it from the connection dialog, or run SELECT @@SERVERNAME. For a local default instance, localhost or a full stop both work. For a named instance it is MACHINENAME\INSTANCENAME.

Windows Authentication, which uses the logged in Windows account, and SQL Server Authentication, which uses a username and password. On an unattended robot, Windows Authentication runs under the robot's service account, which is a frequent cause of a connection that works in development and fails in production.

Because the server differs between development, UAT and production. Hard coding it means a code change and a redeploy for every environment. Store it as an Orchestrator asset and read it at Init, and the same package runs everywhere.

Use the Parameters collection on the activity and reference the parameter in the query, not string concatenation. Concatenating a value into the SQL string is how you get an injection defect and a query that breaks on an apostrophe in a surname.

Run them in SQL Server Management Studio or the equivalent client first, against the same account the robot will use. If it fails there, it is a database problem. If it passes there and fails in UiPath, it is a connection, permission or parameter problem. Debugging a query inside Studio is the slow way to find out.

There is no screen to break. It is an order of magnitude faster, it runs in the background, it does not depend on resolution or selectors, and it can be tested independently. Where the database or API is accessible and permitted, driving the UI instead is a decision you should be able to justify.

The account, not the query. Development typically runs as your Windows user under Windows Authentication. Production runs as the robot's service account, which has not been granted access to that database. Confirm what account the robot runs as, confirm it has been granted the right permissions on the right database, and check whether production requires SQL Authentication instead.

When you would bypass business logic that lives in the application layer. Writing directly to a table skips validation, triggers, audit and downstream events that the application would have fired. If the record has to be created the way a user creates it, drive the UI or call the API. Speed is not worth a corrupted state.

It converts a JSON String into a JObject so individual values can be addressed by key, for example jsonObj("rate").ToString. Without it you are left doing string manipulation on a JSON payload, which is fragile and unnecessary.

Deserialize JSON returns a JObject for a single object. Deserialize JSON Array returns a JArray for a list of objects. Using the wrong one on the wrong payload throws immediately.

Deserialize JSON Array into a JArray, then For Each over it with the TypeArgument set to JObject. Inside the loop, address each field with CurrentItem("fieldName").ToString.

Build the URL with the values in it and navigate to it directly, then extract the result. Many sites accept parameters in the query string, so "https://site.com/convert?from=" + strFrom + "&to=" + strTo + "&amount=" + strAmount replaces four Type Into activities and a Click. Better still, call the site's API if it has one and skip the browser entirely.

Concatenate variables into the URL String and pass it to the Url property of Use Application/Browser or Navigate To: "https://site.com/search?q=" + strTerm. Non string values need .ToString, and values containing spaces or symbols need Uri.EscapeDataString.

When the logic is genuinely easier in code than in activities: complex string parsing, a calculation with many conditions, or a data transformation that would take thirty activities and be unreadable. It is not a licence to write the whole process in VB.NET.

VB.NET and C#, depending on the project's language setting. Python is called through the separate UiPath.Python.Activities package, not through Invoke Code.

Through the Arguments collection on the activity. Each argument is mapped to a variable in the workflow with a direction of In, Out or In/Out, and is referenced by name inside the code block.

It is invisible to the Studio debugger, so a failure inside it gives you a stack trace rather than a highlighted activity. It cannot be understood by a support engineer who does not write .NET. And it moves logic out of the place everyone looks. Use it where it earns its keep and document what it does at the top of the block.

A package is the published artefact, a versioned .nupkg produced by Studio. A process is a specific package version linked to a folder and configured to run there. The same package can back several processes in different folders at different versions.

Publishing archives the project into a versioned NuGet package and sends it to Orchestrator or a local feed, so a robot can execute it. The default local publish location is %ProgramData%\UiPath\Packages.

Each publish increments the version. Orchestrator retains previous versions, and a process can be pointed at any of them. This is what makes rollback a two minute configuration change rather than a redeployment, and it is why publishing over the top of a version is never allowed.

An asset is a shared value or credential stored in Orchestrator and read by processes at runtime. It removes hard coded values from the package, so URLs, file paths, thresholds and credentials change per environment without a code change or a redeploy.

Get Asset for Text, Integer and Boolean assets. Get Credential for Credential assets, which returns the username as a String and the password as a SecureString.

Store them as a Credential asset in Orchestrator. A developer can reference the asset by name and use it at runtime, but the value is encrypted with AES 256 and cannot be read back through the UI. For higher assurance, integrate Orchestrator with CyberArk or Azure Key Vault so the secret never lives in Orchestrator at all.

Because the UAT URL and the production URL are different. Hard coded, the package must be rebuilt and republished for each environment, which means the thing you tested is not the thing you shipped. As an asset, one package promotes through every environment untouched.

A queue is a container of transaction items waiting to be processed. Items are added by a loader, retrieved one at a time by performers, and their status is tracked centrally through the whole lifecycle.

Because a queue gives you distribution, status tracking, retry and reporting for free. Multiple robots can work the same queue without collision. A crash loses one transaction, not the run. And you can answer "what happened to invoice 4471" from the Orchestrator UI instead of from the logs.

Add Queue Item for one item. Bulk Add Queue Items for a whole DataTable in a single operation, which is what you use when loading thousands of rows.

Bulk Add Queue Items. It uploads the whole table in one call. Looping Add Queue Item over ten thousand rows makes ten thousand round trips to Orchestrator and turns a two minute load into an hour.

transactionItem.SpecificContent("FieldName").ToString. The key must match exactly what was set in the Collection when the item was added.

New, added and waiting. In Progress, currently being processed. Successful, completed. Failed, ended with a business or application exception. Retried, failed and re-attempted. Abandoned, left In Progress for around 24 hours with no update. Deleted, manually removed.

Orchestrator marks it Abandoned. It is the signal that a robot picked up the item and died without setting a status, usually because the VM crashed or the job was killed. Abandoned items in your queue are a monitoring alert, not a queue design feature.

Get Transaction Item locks the item as In Progress in the same operation that returns it. A second robot asking for work gets the next New item, not the locked one. This is exactly what a shared Excel file cannot do, and it is why queues exist.

Multiple robots working the same queue in parallel when one robot cannot clear the volume inside the SLA. Orchestrator handles the locking, so no environment locking logic is needed on the UiPath side. It is a licence decision more than a design one.

The Loader, sometimes called the Dispatcher, reads the input source and adds transaction items to the queue. It runs once. The Performer picks items from the queue and executes the business logic. It runs on as many robots as you need. Separating them means the read is not repeated, failures are isolated, and throughput scales horizontally.

Schedule them sequentially rather than concurrently. The Loader runs first and finishes, then the Performer starts on the same robot. You lose parallelism but you keep the queue's tracking, retry and reporting, which is usually the reason you wanted a queue in the first place.

A Standard robot is tied to one specific machine. A Floating robot can run on any machine defined in Orchestrator, because the machine name is not part of its definition. Only Attended and Development robots can be floating. A Standard robot can be converted with the Convert to Floating option.

Create a trigger in the target folder, choose Time, Queue or Event, set the cron schedule or the queue threshold, select the process and the robot or machine, and set the execution target. Time triggers also carry a stop condition for jobs that overrun.

Cron expressions define the schedule for a time trigger as a set of fields covering seconds, minutes, hours, day of month, month and day of week. Orchestrator's advanced trigger option accepts them directly, which is how you express schedules the standard UI cannot, such as the last working day of the month.

A Tenant is a fully isolated Orchestrator instance with its own users, robots, packages, assets and queues. A Folder is a partition inside a tenant used to separate teams or business units, with its own permissions but sharing the tenant's robots and licences. Use tenants to separate environments, folders to separate teams.

Stop is graceful. It raises a request that the process checks with Should Stop or Check Stop Signal, allowing it to finish the current transaction and close cleanly. Kill is immediate and terminates the process where it stands, leaving the transaction In Progress and the application open. Kill is what leaves you with abandoned items.

No. Production needs the Robot only. Studio is a development licence and installing it on a production VM is a licence cost with no purpose, and an audit finding waiting to happen.

Job status and history per process, centralised logs at the activity level, queue statistics with success and failure counts, alerts on job failure and on robot disconnection, and dashboards through Insights. It is the difference between knowing a process failed and finding out from the business the next morning.

A process that runs without needing the screen, using only background compatible activities and input methods. Multiple background processes can share one machine session, which changes the licence maths considerably compared to foreground processes that each need their own session.

The agreed window in which the process must complete, for example all invoices from the previous day processed before 9am. It drives how many robots you licence, how the queue is designed and what your alert thresholds are. Without an SLA, "the bot is slow" is an opinion rather than a breach.

The specific activities that can realistically fail, and no more. Wrapping the entire process in one Try Catch tells you something failed but not what, which is the same as no exception handling with extra steps.

Add a Catch and select the exception type, for example System.Exception, SelectorNotFoundException or BusinessRuleException. Catches are evaluated in order, so specific types must be placed above System.Exception, which catches everything.

Yes. Finally always runs, whether the Try succeeded, an exception was caught, or an exception was thrown and not caught. That is what makes it the right place for cleanup: closing applications, disconnecting from databases, releasing files.

In the Catch, reference the exception variable, which is named exception by default: exception.Message for the message and exception.Source for the activity. Logging "an error occurred" instead is the most common defect in production support.

Throw raises a new exception that you construct, and is used to signal a condition your code has detected. Rethrow re-raises the exception currently being handled, preserving its original type and stack trace, and can only be used inside a Catch. Use Rethrow when you want to log locally and still let the caller handle it.

It stops the workflow immediately with the exception you supply. Unlike Throw, nothing further executes and no Catch upstream will run in that workflow. It is a hard stop, used when continuing would do damage.

A Business Exception means the data is wrong: a missing mandatory field, an invalid format, an amount outside a permitted range. Retrying will not help because the input will not change. An Application Exception, also called a System Exception, means the technology failed: a crash, a timeout, a broken selector, a network drop. Retrying often helps because the condition is usually transient.

Throw with new BusinessRuleException("Invoice amount exceeds approved limit for vendor " + strVendor). The custom message is what appears in the queue and in the report, so it should tell the business what is wrong, not tell a developer where the code broke.

Because they get different treatment. A System Exception is retried and, if it persists, escalated to IT. A Business Exception is never retried and goes to the business to fix the data. Treat them the same and you either retry bad data three times for nothing, or you send an application outage to the accounts payable team.

Execution of the current sequence stops immediately. Any activity after the Throw is skipped, including logging you placed below it. This is why the log or report must be written before the Throw, not after it.

Validate before submission rather than relying on the application to reject it. Some applications accept text in a numeric field, save it, and fail downstream hours later with no link back to your transaction. Check the value against the business rule yourself and throw a BusinessRuleException before the record is created.

Running the process in a controlled way to find defects: stepping through activities, pausing at breakpoints, inspecting variable values in the Locals panel, and reading the Output panel.

Step Into executes one activity at a time and enters invoked workflows, so you see inside a sub workflow. Step Over executes the current activity, including an entire invoked workflow, as a single step without going inside it. Use Step Over when you trust the sub workflow and want to skip past it.

Right click the activity or container and choose Run to this Activity, or Run from this Activity. Set a breakpoint and use Debug. On a long process, rerunning from the top to test the last step is how developers lose an afternoon.

Because Debug pauses on the exception and offers Retry, Ignore and Continue, which is not what happens in production. The Catch may never execute as it would at runtime. Test exception handling with Run, not Debug, or you are testing the debugger.

Trace, Debug, Info, Warn, Error and Fatal. The robot's logging level determines which are written, so a Debug message will not appear in production if the level is set to Info.

Log the exception with its actual message. Take a screenshot. Close the application, usually by killing the process rather than politely closing a hung window. Set the transaction status to Failed with a reason. Then either retry or move on to the next transaction.

Open set to Always and Close set to Always, because recovery cannot assume the application is in any particular state. This is the opposite of the Init configuration, and it is deliberate: recovery is the one place you want a clean launch and a clean close.

An automated exception report: the transaction reference, the exception type, the actual exception message, the timestamp and a screenshot, sent by email or written to a shared log. Build it once as a reusable component and invoke it from every Catch, rather than reimplementing it per process.

Set Transaction Status inside the Catch, passing the QueueItem, a status of Failed, an error type of Application or Business, and a reason. Skip it and the item stays In Progress until Orchestrator abandons it 24 hours later.

A workflow that defines what the project does when an exception is not caught anywhere else. It can log, retry the failing activity, ignore it, or abort the process. Only one is permitted per project and it is set in Project Settings.

Retry Scope re-executes its contents until the condition succeeds or the retry count is exhausted. It is the right activity for a transient failure such as a slow loading page, and the wrong one for bad data, which will fail identically every time.

Look at what you already have before you try to reproduce it. Pull the Orchestrator job log for the failed run and read the actual exception message and the activity that raised it. Pull the screenshot if your reporting captures one. Check whether the failures cluster by time, which points at a batch job or a backup window on the target application. If the logs do not tell you, the fix is not the process, it is the logging, and that is the first change to make.

One time setup: reading the Config file, loading settings, constants and assets, killing leftover processes, opening applications and logging in. It runs once at the start and again after a System Exception.

It is treated as a System Exception and the framework goes straight to End Process. There is no point attempting transactions when the applications did not open or the login failed, so the framework does not try.

Because the environment is in an unknown state. Returning to Init closes and reopens the applications, reloads configuration and re-authenticates, which recovers from a crash or a hung window. Continuing to the next transaction on a broken application just fails every remaining item.

It does not retry. The transaction is marked Failed with a Business error type and a reason, and the framework moves directly to the next transaction. The data is wrong and a retry will produce the same result.

On a System Exception, the framework re-attempts the same transaction up to MaxRetryNumber times before marking it Failed. The retry counter is tracked in Config. Queue level retry is configured on the queue in Orchestrator instead.

Two or three. It is enough to survive a transient network drop or a slow page. Beyond that you are not recovering from a glitch, you are hammering a system that is genuinely down, and multiplying the damage across every item in the queue.

Config.xlsx, in the Data folder, holds every environment specific value: URLs, file paths, thresholds, asset names and retry counts. It is read at Init into a Dictionary. It exists so that moving from UAT to production is a spreadsheet change, not a code change.

Settings, for values that may change per environment such as URLs and paths. Constants, for values that do not change such as the log message prefix and retry count. Assets, which maps a friendly name to an Orchestrator asset name so the value is fetched at runtime.

Because it gives named lookup rather than positional. Config("OrchestratorQueueName") is readable and does not break when a row is inserted into the spreadsheet. A DataTable indexed by row number would.

Settings hold values that vary by environment and are expected to be edited: URLs, paths, mailboxes. Constants hold values that are fixed for the process regardless of environment: retry counts, log prefixes, framework defaults. The split exists so a support engineer editing Settings cannot accidentally change framework behaviour.

The Assets sheet stores the asset name, not the value. At Init the framework calls Get Asset for each row and puts the retrieved value into the same Config dictionary. The value never lives in the file, which is the whole point for credentials.

Because the previous run may have died leaving Excel or the browser open, and a leftover instance will steal focus or block a file. Killing them first guarantees a clean start rather than inheriting the last run's mess.

Init distinguishes the first entry from a re-entry after a System Exception. On the first run it reads Config and initialises everything. On a re-entry it skips the Config read, since the configuration has not changed, and only reopens the applications. It is controlled by checking whether Config is Nothing.

Because a resolution mismatch between the development machine and the production VM breaks image based and coordinate based steps, and the failure looks like a random selector problem. Logging it at Init means the first support question is answered before it is asked.

In the Invoke Workflow File activity, click Import Arguments and map each argument to a variable of a matching type. If you add an argument to a workflow later, you must reopen Import Arguments in every caller, or the mapping silently stays stale.

Get Transaction Data returns Nothing when the queue is empty, TransactionItem is null, and the framework transitions to End Process and closes cleanly. An empty queue is a normal outcome, not an error, and it should not raise an alert.

A workflow type built from a finite set of states connected by transitions. Execution enters a state, runs its logic, then follows the transition whose condition is satisfied. It suits long running processes with a defined lifecycle.

State, Final State and Transition. State and Final State are dragged onto the canvas, transitions are drawn between them.

A Final State has an Entry section but no Transitions, because nothing follows it. It terminates the State Machine. End Process in the RE Framework is a Final State.

Yes. A transition has an Action section that executes as the transition is taken, after the source state's Exit and before the target state's Entry. It is used for setting a flag or logging the routing decision.

Because the framework needs to route back to a previous stage repeatedly and conditionally. A System Exception in Process must return to Init. A completed transaction must return to Get Transaction Data. An empty queue must go to End. A State Machine expresses that routing explicitly as conditions on transitions, where a Flowchart would become a tangle of connectors.

Init to Get Transaction Data on success, or to End Process on a System Exception. Get Transaction Data to Process Transaction when an item exists, or to End Process when the queue is empty. Process Transaction back to Get Transaction Data on success or Business Exception, back to Init on a System Exception, or to End Process when stopped.

The failure raises a System Exception in Process Transaction. The current transaction is marked Failed with an Application error type, and the framework transitions back to Init, which kills and reopens the applications and retries. If the server is still down, it fails again and the retry count is exhausted, and the process continues to the next transaction and fails that one too. This is why an availability check in Init and an alert on consecutive failures matters more than the retry count itself.

Nothing in the package should change. Update the Settings and Assets sheets in Config, or better, change the Orchestrator assets in the production folder. Point the production process at the published package version. If you are editing .xaml files to change environment, the Config file is not being used as intended.

Split Loader and Performer if they are not already split, then run multiple Performers against the same queue. Orchestrator handles the locking, so no code change is required to scale. Before buying licences, check whether the per transaction time is the real problem, because a process with forty 3 second Delay activities is a tuning problem, not a capacity problem.

Verify Expression, Verify Expression with Operator, Verify Control Attribute and Verify Text. Verify Expression is the general case and evaluates a Boolean.

It evaluates the expression. True passes, false fails and the test case is marked failed with the message you supplied. It does not throw, so the test continues and reports every failure rather than stopping at the first.

Test Manager is the web application for managing testing: organising test cases, linking them to requirements, building test sets, scheduling execution, and reporting results and coverage. It connects to Studio and to Orchestrator.

A named collection of test cases executed together, for example a regression suite or a smoke test. Test Sets are scheduled and run through Orchestrator like any other process.

Coverage and skills. Selenium tests browsers and needs code. Test Suite tests browsers, desktop applications, Citrix, SAP, mainframe, APIs and databases in one tool, using the same skills the RPA team already has. Where the application under test is web only and the team already writes Java, Selenium is the cheaper answer and you should say so.

Do not rely on the tab index. Use Attach Browser or Use Application/Browser targeting the new tab's URL or title, with a wildcard on the volatile part. Tab order changes between runs and a test that depends on it fails for reasons that have nothing to do with the application.

UiPath Apps builds a web front end for an automation without a developer. Business users get a form, they submit it, a robot runs, and the result comes back to the same screen. It replaces the pattern of emailing a spreadsheet to trigger a bot.

When a human needs to supply the input and the process is unattended. Input Dialog blocks an unattended robot waiting for a click that will never come. Apps collects the input first and then triggers the robot, so the human interaction and the automation are properly separated.

It must be published to Orchestrator and added as a process in the target folder. Apps binds to the Orchestrator process, not to the Studio project. A change in Studio is not visible in Apps until it is republished and the process version is updated.

Binding connects a control on the app to a process argument or an app variable, so a text box's value flows into an In argument and an Out argument flows into a label. It is the mechanism that replaces writing any integration code.

Because it lets a variable number of fields pass through a single argument instead of maintaining twenty arguments and rebinding the app every time the business adds a field. It is the same reason the RE Framework's Config is a dictionary.

Autopilot generates an app from a natural language description or from an existing form, producing the layout and controls as a starting point. It is a first draft, not a finished app, and the binding still needs to be checked.

Publish the process to Orchestrator. Prepare the Windows machine and install the Robot. Create the machine and the unattended robot in Orchestrator and connect them. Create the process in the target folder pointing at the package version. Configure the assets and the queue. Create the trigger.

Attended, triggered by a user on their own machine. Unattended, triggered by Orchestrator on its own machine. Testing, used to execute automated test cases. Non-Production, used for development and UAT environments without consuming a production licence.

Studio and StudioX for development, StudioPro or Testing for test development, Attended robot, Unattended robot, Non-Production robot, and Orchestrator tenant licensing. Document Understanding and AI Center are licensed separately by consumption.

A library is a project published as an activity package. Its workflows become activities that other projects install through Manage Packages. It is how common logic such as login, exception reporting or a standard Excel read is shared across a team without copying .xaml files.

Because an argument becomes a visible property on the resulting activity and a variable does not. A library workflow built with variables produces an activity nobody can pass anything to.

It should not be in the library at all. The library takes a credential as an In argument, or fetches it from an Orchestrator asset at runtime. A password baked into a library is distributed to every project that installs it and lives in a package you cannot easily recall.

Publish the library with a new version, then in each consuming project open Manage Packages and update to that version. Consumers do not update automatically. This is a feature, because an automatic update would push an untested change into production, and it is also why library versioning has to be disciplined.

The items are stuck In Progress and Orchestrator will abandon them after roughly 24 hours, which is too late. Query the queue for In Progress items older than your SLA, reset them to New so they are picked up on the next run, and record that they were reset. Then find out why the VM crashed, because a queue that needs manual resets weekly is not a queue problem.

Screen resolution differing between the UAT VM and production. The robot's service account lacking permissions the developer's account had. Assets pointing at UAT values because the production folder was never configured. Production data volume and variety that UAT never contained. And Outlook or Excel not being configured under the robot's account. In practice it is almost never the logic, because the logic is what UAT tested.