Robotic Process

Automation

MODULE-5: Managing and Maintaining the Code,

Deploying and Maintaining the Bot

Sanjeela Sagar
[email protected]

Vidyalankar School of
Information Technology
Wadala (E), Mumbai
www.vsit.edu.in
 Certificate
This is to certify that the e-book titled “Robotic Process
automation” comprises all elementary learning tools for a better
understating of the relevant concepts. This e-book is comprehensively compiled as per the
predefined eight parameters and guidelines.

Signature Date: 25-11-2023

Sanjeela Sagar
Assistant Professor
Department of IT

DISCLAIMER: The information contained in this e-book is compiled and distributed

for educational purposes only. This e-book has been designed to help learners understand
relevant concepts with a more dynamic interface. The compiler of this e-book and
Vidyalankar School of Information Technology give full and due credit to the authors of
the contents, developers and all websites from wherever information has been sourced.
We acknowledge our gratitude towards the websites YouTube, Wikipedia, and Google
search engine. No commercial benefits are being drawn from this project.
Unit 5
Managing and Maintaining the Code: Project organization, Nesting workflows,
Reusability of workflows, commenting techniques, State Machine, When to use
Flowcharts, State Machines, or Sequences, Using config files and examples of a
config file, Integrating a TFS server
Deploying and Maintaining the Bot: Publishing using publish utility, Overview of
Orchestration Server, Using Orchestration Server to control bots, Using
Orchestration Server to deploy bots, License management, Publishing and
managing updates.

Recommended Books
• Learning Robotic Process Automation, Alok Mani Tripathi, Packt, 1st, 2018
• Robotic Process Automation Tools, Process Automation and their benefits: Understanding
RPA and Intelligent Automation, Srikanth Merinda, CreateSpace Independent Publishing,
1st, 2018
• The Simple Implementation Guide to Robotic Process Automation (Rpa): How to Best
Implement Rpa in an Organization, Kelly, Wibbenmeyer, iUniverse, 1st, 2018

Prerequisites and Linking

Pre-requisites Linkage
Unit V
Sem 1 Sem VI

Robotic Process Programming Logic Project

Automation
Q.1 What are the best practices considered while working on a project? Explain.

While working on any automation project, it is very important to work with a proper set of rules so that
the project can be organized in an efficient way. In UiPath, the following are some of the best practices
considered while working on a project:

Pick an appropriate layout for each workflow:

There are various layouts available while creating a new project. Among those layouts, we have to
choose the best option on the basis of the type of automation process we are undertaking. All the
layouts are shown in the following screenshot:

• Blank
• Simple Process
• Agent Process Improvement
• Transactional Business Process

Break the whole process into smaller parts:

To build any project, we have to use various activities. But using too many activities makes the project
clumsy and it is not readable. We have to design our project in such a way that each independent part
resides alone. We can achieve this by using workflows. We should put each independent part of the
project inside a single workflow. We can invoke all the workflows inside the project at the appropriate
position. Dividing the project into workflows makes the project cleaner and more maintainable. Now, if
any developer wants to debug your code, they can check the different workflows and easily pinpoint in
which workflow a particular error occurred. If the project is not divided into workflows, it will be a
nightmare for the developer to fix any error. Thus, breaking an automation into smaller parts enables
easy debugging, as well as the workflows across projects.

Use exception handling:

While working on a project, it is better to use exception handling because it reduces the risk of errors.
For instance, using the Try catch block can give you a proper error message, which helps us handle
exceptions. There are various exception handling techniques that have been explained earlier and that
are very useful while working on a project. An example featuring using the Try catch activity to handle
exceptions has been shown in the figure. Here, we have used the Write line activity to display messages
in the case of any error detected by the Catch block or the Finally block.

Make your workflow readable:

It is good practice to name activities based on the operations they perform to ensure that when we
return to the workflow, we can easily identify each and every step used in it. This becomes very helpful
while finding and resolving errors as it specifies the process when showing an error during debugging. If
activities are properly named, we get to know exactly which part of the workflow is not working. For
example, we will create a workflow that will ask the user to guess a number, based on which we will
perform an addition and finally display the answer. The following screenshot shows the proper naming
of the steps involved in the process.

Keep it clean:

Just as writing in a clean and understandable manner is the quality of a good coder, the same holds true for an
RPA developer. Clean code helps us understand the whole process very easily-you and whoever is reading it.

Q.2 How exception handling can be useful? Explain

Exception handling is a way to handle exceptions for a process that the program or the procedure has
failed to execute. For handling exceptions in a program, the best practice considered is to use the Try
catch activity.
The Try catch activity can be found in the Activities panel. By dragging and dropping the Try catch
activity into the workspace, we can handle exceptions. For handling errors in the Try catch block, we can
divide the whole process into four parts just to make it simpler:

• Drag and drop the Try catch activity.

• Try block.
• Catch block.
• Finally block.

Let's build a Try catch block to handle exceptions, in following steps:

 1) Drag and drop the Try catch activity: Create a blank project. Drag and drop the Flowchart activity
into the Designer panel. Search for the Try catch activity in the Activities panel and drag it into
the Flowchart. Set it as the Start node.

2) Try: When we double-click on the Try catch activity, dragged, and dropped inside the workspace,
space for the Try activity appears, as shown in the following screenshot:

a. Inside the Try block, we have to drop the activity we want to perform. Drop a Write line
activity to test the working of Try Catch block, as shown in the following screenshot:

3) Catches: Inside the Catches activity, first we have to click on Add new Catch and then click on
Add Exception option, from which we have to select the type of exception. In most cases,
System.

a. Exception is preferred. The following screenshot shows the types of exception. There are
many more exceptions which can be viewed by clicking on the Browse for Types option:

b. Say the execution fails: for example, the Click activity is unable to be executed because of
the unavailability of a UI element. In such a case, we can use the Catches block to either
view the error that has occurred or for an alternative method to be used if that particular
error occurs. As shown in the following screenshot, we will drop the activity in the
Catches block. To print a message, we use a Message box:

c. When we click on Add new catch, we are asked to select the type of exception. We have
selected System. Exception. Now inside the exception block, we have dropped a Message
box activity. Entering some keys will display the error that occurred during execution.

4) Finally: When we have defined the exception for our sequence, the Final block will always work,
regardless of whether the execution was successful or not. Suppose we want to display a
message to the user notifying that the process is complete. To make sure that the whole Try
catch activity is executed, we will just drop a Message box activity in the area provided in the
Finally block, as shown in the following screenshot:

Common exceptions and ways to handle them Implementing exception handling enables the robot to
work in every possible situation and tackle any exception that may arise. There are some common
exceptions that we usually face while working on UiPath.

Q.3 How to nest a workflow inside a single workflow? Explain with an example.
Nesting a workflow inside another workflow in UiPath allows you to create modular and reusable
automation components. It's a useful approach when you have a set of activities that you want to use in
multiple places within a larger automation process. Here's how to nest a workflow inside another
workflow, along with an example:

Step 1: Create the Nested Workflow (Reusable Component)

1. Open UiPath Studio.
2. Create a new workflow by clicking "New" and selecting "Sequence" or "Flowchart." This will be your
reusable component.
3. Add the activities and logic specific to the functionality you want to encapsulate. This could be a series
of actions or a process that you want to reuse.

Example of a Nested Workflow (Reusable Component):

Let's say you want to create a reusable workflow to log in to a web application. Your reusable
component might contain activities to navigate to the login page, enter credentials, and click the login
button.

plaintext
Flowchart (LoginToWebApp)
|--- Navigate to Web App Login Page
|--- Type Username
|--- Type Password
|--- Click Login Button

Step 2: Invoke the Nested Workflow

Now that you have your reusable component (LoginToWebApp), you can use it in a larger workflow (the
parent workflow).

1. Open or create a new workflow that requires the login functionality. This is your parent workflow.

2. To use the nested workflow, drag the "Invoke Workflow" activity into the parent workflow. You can
find this activity in the Activities panel on the left.

3. In the "Invoke Workflow" activity, specify the nested workflow (LoginToWebApp) by selecting it from
the drop-down menu.

4. Define the input and output arguments if your nested workflow requires any parameters from the
parent workflow or if it returns any values.

Example of Using the Nested Workflow in the Parent Workflow:

In your parent workflow, you can use the nested "Login to Web App" workflow to automate the login
process. Here's an example:
plaintext
Sequence (Main Workflow)
|--- Open Browser to Web App
|--- Invoke Workflow (Login to Web App) // Here, you invoke the nested workflow
|--- Perform Other Actions
|--- Close Browser
This structure allows you to encapsulate and reuse the login process in multiple places within the main
workflow or even in other workflows.

By nesting workflows, you create more modular and maintainable automation solutions. If you need to
make changes to the login process, you can update the nested workflow (LoginToWebApp) without
affecting the rest of your automation. This promotes efficient development and easier maintenance of
your automation projects.

Q.4 What are the different methods of reusing workflows? Explain.

In UiPath, there are several methods for reusing workflows, which allow you to create modular and
maintainable automation solutions. Here are the different methods of reusing workflows, along with
explanations:

1. Invoke Workflow Activity:

- The "Invoke Workflow" activity is a fundamental method for reusing workflows in UiPath. It allows
you to call and execute another workflow from within your main workflow.
- You can pass input arguments to the invoked workflow and receive output arguments from it, making
it highly flexible and reusable.
- This method is suitable for encapsulating specific functionalities or processes that are used in
multiple places within your automation project.

2. Library Projects:
- UiPath Libraries enable you to create reusable automation components that can be used across
multiple automation projects.
- You can create custom libraries that contain sequences, workflows, and custom activities.
- Libraries are particularly useful when you want to share and reuse automation components across
different projects or with other developers. They are stored in a shared location.

3. Custom Activities:
- You can create custom activities using UiPath's activity development capabilities.
- Custom activities are reusable building blocks that encapsulate specific functionality. They can be
added to your automation projects as if they were native UiPath activities.
- This method is suitable when you have a specific set of actions that you want to use across different
projects without rewriting the same logic.

4. Subroutines and Functions:

- Within a workflow, you can create subroutines (e.g., using the "Invoke Method" activity) or functions
to encapsulate and reuse pieces of code.
- These subroutines or functions are called as needed within the workflow.
- This approach is useful for creating small reusable components within a single workflow.

5. Arguments and Variables:

- Utilizing arguments and variables within workflows allows you to pass and store values, making your
workflows more dynamic and reusable.
- By using arguments and variables effectively, you can create more adaptable automation
components.

6. Template Workflows:
 - You can create template workflows that serve as starting points for new projects or processes. These
templates can include standardized activities, configurations, and guidelines.
- Templates are especially helpful when you have recurring automation requirements or specific
company standards to follow.

7. Orchestrator Assets:
- UiPath Orchestrator allows you to store and manage reusable assets, such as credentials, certificates,
and queues, which can be used across different projects and workflows.
- Assets can be securely managed and accessed through Orchestrator, providing centralized control
and reuse.

8. NuGet Packages:
- You can package and distribute reusable workflows, libraries, or custom activities as NuGet packages.
- This method is beneficial when you want to share automation components with other UiPath
developers or teams.

These methods offer a range of options for reusing workflows and automation components in UiPath.
The choice of method depends on the specific requirements of your projects and the level of reusability
and sharing you need. By effectively reusing workflows, you can streamline development, improve
maintainability, and accelerate the automation process.
Q.5 How to use comment in a workflows? Which activity is used for commenting?
Explain.
[ANS] Comments in workflows are essential for documenting your automation logic and making it more
understandable to both yourself and other developers who may work with your automation projects.
UiPath provides a dedicated "Comment" activity for this purpose.

Here's how to use the "Comment" activity in UiPath:

1. Add a Comment Activity:

- Open your workflow in UiPath Studio.
- In the Designer panel on the right-hand side, you'll find a toolbox with activities. Search for the
"Comment" activity.
- Drag and drop the "Comment" activity into your workflow where you want to add the comment.

2. Edit the Comment:

- After adding the "Comment" activity, you can double-click on it to open the Comment Editor.
- In the Comment Editor, you can enter your comments, notes, or explanations about the adjacent
activities or workflow. This is where you provide context or describe the purpose of the workflow
elements.

3. Format and Style:

- You can format the comment using standard text formatting options, such as bold, italics, and bullet
points, to make your comments more organized and readable.

4. Save and Close:

- After editing the comment, click the "OK" or "Save" button to save your comment.
5. Arrange Comments:
- You can move and resize the comment activity to place it near the activities you're documenting. This
helps to provide context and explanations right where they are needed.

Comments are a valuable tool for making your workflow more understandable and maintainable. They
allow you to explain complex logic, provide instructions for other developers, and clarify the purpose of
various workflow elements. Properly documented workflows can significantly improve collaboration and
the long-term maintainability of your automation projects.

Keep in mind that while comments are helpful, it's also essential to maintain a clean and organized
workflow design to ensure that your automation is efficient and easily comprehensible.

Q.6 Write a short note on state machine.

A state machine is a computational model used in computer science and automation to represent and
control the behavior of a system. It's based on the concept of states, transitions, and events. In a state
machine, a system can exist in one of several predefined states, and transitions between these states
are triggered by events or conditions. Here's a short note on state machines:

Key Concepts of State Machines:

1. States: States represent different conditions or modes that a system can be in. For example, in a
simple vending machine, states could include "idle," "selecting product," "dispensing," and "out of
order."

2. Transitions: Transitions are the paths between states. They indicate how the system moves from one
state to another in response to events or conditions. Transitions often have associated actions that are
performed during the transition.

3. Events: Events are external or internal triggers that cause a transition from one state to another. In
the vending machine example, an event could be a user pressing a button to select a product.

4. Actions: Actions are tasks or operations performed when a transition occurs. They can include
calculations, updates to data, or external interactions. In the vending machine context, an action could
be dispensing the selected product.

Benefits of State Machines:

- Modularity: State machines encourage a modular and organized design of complex systems. Each state
can encapsulate a specific behavior or function, making it easier to manage and understand.

-Predictability: State machines offer a clear and predictable way to model and control the behavior of a
system. You can define and visualize the entire system's behavior in a structured manner.

-Scalability: State machines are flexible and can be scaled to handle larger and more complex systems.
They can be extended by adding new states, transitions, and events as needed.

- Debugging and Testing: State machines facilitate debugging and testing because the behavior of the
system is well-defined and can be examined step by step.
- Real-World Applications: State machines are widely used in various fields, including software
development, robotics, industrial automation, and game development. They are ideal for modeling
systems with sequential and conditional behaviors.

In software development, state machines are employed for building applications that require a
controlled flow of events, such as chatbots, workflow management, and user interfaces. State machines
provide a structured and maintainable way to implement and manage complex decision-making and
control logic within software systems.

Q.7 When to use Flowcharts, State Machines, or Sequences? Explain.

Flowcharts, State Machines, and Sequences are three common workflow design styles in UiPath, each
suited to different scenarios. Understanding when to use each design style is crucial for creating
efficient and maintainable automation solutions. Here's an explanation of when to use each one:

1. Flowcharts

- When to Use: Flowcharts are ideal when your automation process involves a complex, non-linear
flow of actions with various decision points.
- Scenarios:
- Multi-branch Logic: Use flowcharts when your process requires multiple decision points that can
lead to different outcomes.
- Interactivity: Flowcharts are useful for processes where user interaction or intervention may be
required.
- Clear Visualization: They are excellent for visualizing and documenting complex business processes.
- Benefits: Flowcharts provide a clear and visual representation of the workflow, making it easier for
developers and stakeholders to understand the process.

2. State Machines:
- When to Use: State machines are suitable for processes with distinct and well-defined states where
the sequence of states and transitions between them are critical.
-Scenarios:
- Sequential Logic: Use state machines when your process can be represented as a series of well-
defined states with transitions.
- Conditional Logic: When your process involves conditional branching and decision-making based on
the current state.
- Robotic Process Automation (RPA): State machines are commonly used in RPA to handle complex
business processes with various states and conditional transitions.
- Benefits: State machines are excellent for modeling processes with sequential and conditional
behaviors. They provide a structured and organized way to represent the system's behavior.

3. Sequences:

- When to Use: Sequences are suitable for linear and straightforward automation tasks where the flow
of actions is primarily sequential.
- Scenarios:
- Simple Tasks: Use sequences for single or linear sets of actions that don't involve complex branching
or conditional logic.
 - Automation of Repetitive Tasks: For automating repetitive tasks with a clear start-to-finish
sequence.
- Data Entry and Validation: Sequences are often used for data entry, validation, and straightforward
data manipulation.
- Benefits: Sequences are easy to create, understand, and maintain. They are suitable for tasks with
minimal complexity and branching.

Key Considerations:

- When choosing a design style, consider the complexity and structure of your automation process.
Flowcharts are better for complex, decision-heavy processes, state machines excel in situations with
well-defined states and transitions, and sequences are perfect for linear, straightforward tasks.

- It's common to use a combination of these design styles within a single automation project. For
example, you might use a sequence for a straightforward login process and a state machine for a more
complex order processing workflow within the same project.

- Documenting and visualizing your workflow is essential, regardless of the design style you choose.
Clear documentation helps with understanding and maintaining your automation processes.

Ultimately, the choice between flowcharts, state machines, and sequences depends on the nature of
the process you are automating and your preference for structuring and visualizing the workflow.

Q.8 How to use config files? Give an example of a config file.

Configuration files, often referred to as "config" files, are used to store and manage settings,
parameters, and variables that your automation processes require. Using config files in UiPath can make
your workflows more flexible, maintainable, and easily configurable. Here's how to use config files,
along with an example:

How to Use Config Files:

1. Create a Config File:

- You can use various formats for config files, such as JSON, XML, or even plain text. Choose the format
that suits your needs.
- Create a file that contains the configuration settings for your automation project. Each setting should
have a key and a corresponding value.

Here's a simple example in JSON format:

json
{
"Username": "myusername",
"Password": "mypassword",
"APIKey": "myapikey",
"MaxRetries": 3,
"TimeoutInSeconds": 30
}
2. Store the Config File:
- Save the config file in a secure and accessible location, such as a dedicated folder within your project
or a shared directory.
- Ensure that the file format is supported by UiPath for easy reading and parsing.

3. Read and Parse the Config File:

- In your UiPath workflow, use activities to read and parse the config file. The specific activities will
depend on the file format (e.g., "Read Text File" for plain text or "Deserialize JSON" for JSON).
- Load the content of the config file into a variable or data structure.

4. Access Configuration Settings:

- You can access individual configuration settings by referencing their keys from the loaded config file
data.
- Store these settings in variables within your workflow for easy access.

Example of Using a Config File:

Let's say you have a UiPath automation project for web scraping that requires configuration settings.
You can create a config file as shown above and use it in your workflow like this:

plaintext
1. Read Text File: Read the content of the config file into a variable (e.g., `configText`).

2. Deserialize JSON: Use this activity to deserialize the `configText` variable into a JSON object. Store the
result in a variable (e.g., `configData`).

3. Access Configuration Settings:

- To access the "Username" setting, use `configData("Username").ToString()`.
- To access the "Password" setting, use `configData("Password").ToString()`.
- For other settings, follow a similar pattern.

4. Use the configuration settings in your workflow as needed, such as logging in with the provided
credentials or using the API key.

5. This configuration file can be easily modified without changing the workflow. If the settings change,
you only need to update the config file.

Using config files in this manner allows you to centralize and manage configuration settings, making
your automation projects more adaptable and easier to maintain. It also facilitates changes to settings
without modifying the workflow, which is especially valuable in enterprise-scale automation.

Q.9 How will you integrate a TFS Server? Explain.

Integrating a Team Foundation Server (TFS) with UiPath involves using TFS as a version control system
for managing your UiPath projects. This integration allows you to track changes, collaborate with team
members, and ensure the versioning of your automation projects. Here are the steps to integrate TFS
Server with UiPath:
Prerequisites:
1. Team Foundation Server (TFS): Ensure you have access to a TFS server where you have appropriate
permissions to create and manage projects and repositories.
2. UiPath Studio: Make sure you have UiPath Studio installed and configured on your development
machine.
Integration Steps:
1. Create a TFS Project:
- In TFS, create a new project that will serve as your repository for UiPath projects.

2.Clone or Connect to the TFS Repository

- In UiPath Studio, open the project you want to integrate with TFS, or create a new project.

- If you have an existing project, you can connect it to the TFS repository. To do this, navigate to the
"Team" tab in UiPath Studio and select "Connect to TFS." Provide the TFS server URL and credentials.

- If you're creating a new project, you can clone it directly from the TFS repository. In UiPath Studio, go
to the "Team" tab and select "Clone from TFS." Provide the TFS server URL and credentials.

3. Add Your Project to the Repository:

- Once connected or cloned, your UiPath project is linked to the TFS repository. You can add your
project files and assets to the TFS project.

4. Commit and Push Changes:

- Make changes to your project in UiPath Studio.

- To commit your changes to TFS, go to the "Team" tab and select "Commit." You can add comments
to describe the changes.

- After committing, you need to push your changes to the TFS repository. Use the "Push" option in the
"Team" tab.

5. Branching and Merging (Optional):

- TFS allows for branching and merging. You can create branches for parallel development and merge
changes when ready.

6. Pull and Update (Optional):

- If you're working in a team, you may need to pull and update your project to sync with the latest
changes from the TFS repository. Use the "Pull" and "Update" options in the "Team" tab.

By following these steps, you can effectively integrate a TFS Server with UiPath Studio, enabling version
control and collaboration with team members on your automation projects. This integration facilitates
better project management and tracking of changes, making it easier to work in a team environment
and ensure the reliability of your automation solutions.

Q.10 How will you publish a workflow in UiPath? Explain.

Publishing a workflow in UiPath involves creating a package from your project and making it available
for execution on different environments, including UiPath Robots. This process ensures that your
automation is properly deployed and executed. Here's a step-by-step guide on how to publish a
workflow in UiPath:

Publishing Workflow in UiPath:

1.Open Your Project:
- Open your UiPath project in UiPath Studio, ensuring that it's fully developed and ready for
deployment.

2. Check Project Dependencies:

- Verify that your project does not have any unmet dependencies. Dependencies could include custom
libraries, packages, or external resources. Make sure all dependencies are correctly referenced.

3. Configure Project Settings:

- Before publishing, it's a good practice to configure your project settings, including input arguments,
output arguments, and any configuration values. Ensure that your workflow is set up to run efficiently in
the target environment.

4.Save Your Project:

- Save your project to ensure that any recent changes are saved.

5. Publish Your Project:

a. Go to the "Design" tab in UiPath Studio.

b. Click on the "Publish" button in the "Publish" group.

c. In the "Publish Project" window that appears, you can define the publishing package settings:
- Process Version: Assign a version number to your project. It's a good practice to use semantic
versioning (e.g., 1.0.0).
-Publish Location: Specify the directory where the package will be published. This is typically a local
or network folder.
- Package Name Name the package to be published.
- Description Provide a brief description of the package.

d. Click the "Publish" button.

e. UiPath Studio will create a package (a .nupkg file) in the specified publishing location. This package
contains your automation project, dependencies, and configuration.

6. Distribute the Package:

- Share the package with other team members or upload it to Orchestrator if you're using UiPath
Orchestrator for centralized automation management.
7. Deploy the Package:
- To execute the workflow on a UiPath Robot, you'll need to deploy the package to the Robot's
machine. This can be done through UiPath Orchestrator or manually by copying the package and
running it using the UiPath Assistant or command-line execution.

8. Execution:
- The published workflow can now be executed on the target environment, whether it's a local
machine or a UiPath Robot managed by Orchestrator.

Q.11 How to writing/edit the published package info into the .json file? Explain.
To edit the published package information in a `.json` file, you typically need to update the
`package.json` file for the specific package you want to modify. This is a common task when you are
working with Node.js or any other development environment that uses `package.json` files to manage
dependencies and package metadata. Here are the steps to do this:

1. Locate the Package Directory:

First, navigate to the directory where the package you want to edit is located. The `package.json` file
should be in the root directory of the package.

2. Open the `package.json` file:

You can use a code editor, text editor, or a command-line text editor like `nano` or `vim` to open the
`package.json` file for the package you want to edit.

Example command using `nano`:

```

nano package.json

```

3. Edit the `package.json` File:

Inside the `package.json` file, you can edit the relevant fields you want to change. Common fields
include `name`, `version`, `description`, `author`, `license`, and `dependencies`. Make the
necessary changes to the JSON object.

For example, if you want to update the version of the package, change the `version` field:

```json

"name": "your-package-name",
 "version": "new-version",

"description": "Your package description",

"author": "Your Name",

"license": "MIT",

"dependencies": {

"dependency-name": "dependency-version"

```

4. Save the File:

Save the changes to the `package.json` file. If you're using a command-line text editor like `nano` or
`vim`, there are usually instructions at the bottom of the terminal on how to save and exit.

5. Commit Changes (if using version control):

If your project is under version control (e.g., Git), make sure to commit your changes. This step is
important for tracking changes in your codebase.

6. Publish the Updated Package (if needed):

If you're working on a package that you intend to publish, you'll need to follow the process for
publishing the updated package. This typically involves running a command like `npm publish`
or `yarn publish` after making changes to the `package.json` file.

7. Test Your Changes:

Before publishing, it's a good practice to test your package to ensure that it works correctly with the
new changes.

Q. 12 What are the logical components of UiPath Orchestrator?

UiPath Orchestrator is a web-based platform that provides centralized control and management of
UiPath Robots, processes, and related automation assets. It consists of several logical components that
work together to facilitate the automation of tasks and processes. The main logical components of
UiPath Orchestrator include:

1.Tenant:
 - A Tenant is an isolated workspace within Orchestrator that allows you to manage and configure
automation resources separately. Tenants can be used to segregate different business units or
departments within an organization.

2.Organization Units:

- Organization Units are sub-divisions within a Tenant. They help organize and manage automation
resources within a Tenant. Each Organization Unit can have its own set of users, roles, and permissions.

3.Users and Roles:

- Orchestrator allows you to define user roles and assign users to these roles. Roles determine the
permissions and access levels for users. Common roles include Administrator, Robot, and Developer.

4.Assets:

- Assets are key-value pairs that can store information such as usernames, passwords, or other
configuration data. These assets can be securely managed and used in automation processes.

5.Robots:

- Robots are the software agents that execute automation processes. Orchestrator manages the
configuration, deployment, and execution of Robots. It can be on a single machine (Attended Robot) or
on a server (Unattended Robot).

6.Environments:

- Environments are used to group Robots together, allowing you to deploy processes to specific groups
of Robots. This makes it easier to manage automation execution.

7.Processes:

- A process is an automation workflow developed in UiPath Studio. Orchestrator allows you to publish,
schedule, and manage the execution of these processes on Robots.

8.Queues:

- Queues are used to manage and prioritize the work items that need to be processed by Robots. They
enable the handling of large volumes of transactions efficiently.

9.Schedules:

- Orchestrator allows you to define schedules for running processes at specific times or intervals. This
feature automates the execution of processes.

10.Jobs:

- Jobs represent the execution instances of processes on Robots. Orchestrator keeps track of job
status, logs, and other information related to the execution of each job.
11.Logs:

- Orchestrator maintains detailed logs of all actions and events, providing a comprehensive audit trail.
This is crucial for debugging and monitoring automation processes.

12.Monitoring and Reporting:

- Orchestrator offers monitoring and reporting features to track the performance of Robots,
processes, and queues. It provides insights into the health and efficiency of your automation ecosystem.

13.Integration and API:

- UiPath Orchestrator provides APIs for integration with other systems and tools. This allows you to
automate processes that involve interaction with external applications.

14.Security:

- Orchestrator includes security features to protect sensitive data, user access, and system integrity. It
supports Single Sign-On (SSO) and role-based access control.

15.High Availability (HA):

- Orchestrator can be set up in a high-availability configuration to ensure system reliability and

redundancy.

Q.13 What are Queues in UiPath? What are various activities that support this feature?
Key Concepts and Features of UiPath Queues:

1.Queue Items:

- A queue item represents an individual work item or transaction that needs to be processed by a robot.
Each queue item typically contains relevant data and metadata.

2.Prioritization:

- You can prioritize queue items, allowing robots to process high-priority items before lower-priority
ones. This helps optimize automation efficiency.

3.Retry Mechanism:

- Queues support a built-in retry mechanism, which can be configured to automatically retry failed
items a certain number of times or after a specified delay.

4.Deadlines:

- You can set deadlines for queue items, ensuring that items are processed within a defined timeframe.

5.Processing Order:
 - Queue items are processed in a First-In, First-Out (FIFO) order by default. However, you can customize
the order by defining sorting criteria.

6.Logging and Monitoring:

- UiPath Orchestrator provides detailed logging and monitoring features for queue items, including
status, processing time, and error information.

7.Assignment and Ownership:

- Queue items can be assigned to specific robots or left unassigned for robots to pick up. This allows
for workload distribution.

8. Filtering and Searching:

- You can filter and search for queue items based on various criteria, such as status, priority, and
processing time.

Activities Supporting UiPath Queues:

UiPath provides a set of activities specifically designed to interact with and manage queue items. Some
of the key activities include:

1.Add Queue Item:

- This activity is used to add new queue items to a specified queue. You can provide the necessary data
and properties for the queue item, such as reference, content, and priority.

2.Get Queue Items:

- This activity retrieves a list of queue items that match specific filtering criteria. You can filter items by
status, priority, and other properties.

3.Get Transaction Item:

- Used by robots to get the next available queue item for processing. This activity also marks the item
as in progress.

4.Set Transaction Status:

- After processing a queue item, this activity is used to update the status of the item, marking it as
successful, failed, or abandoned.

5.Add Transaction Item:

- Similar to "Add Queue Item," this activity adds a new transaction item to a queue and allows you to
specify data and properties.

6.Process Transaction:
 - This activity is used within a state machine workflow to process transactions. It helps automate the
retrieval, processing, and updating of queue items.

7.Get Transaction Data:

- This activity retrieves transaction data and allows you to access specific fields and information within
a queue item.

These activities, along with UiPath Orchestrator, provide a comprehensive set of tools for managing
queues and effectively automating work item processing in a structured and organized manner .

Q.14 What are the different types of Assests? Explain.

In UiPath, assets are a way to securely store and manage sensitive information, configuration settings,
or other data that can be used by your automation processes. Assets are crucial for maintaining the
security and flexibility of your robotic process automation (RPA) workflows. There are two main types of
assets in UiPath: Credential Assets and Non-Credential Assets.

1.Credential Assets:

- Username/Password: This type of asset is used to securely store credentials, such as usernames and
passwords, which are commonly needed for logging into applications, systems, or websites. UiPath
encrypts and protects these credentials.

- Windows Credential: This asset type is specifically used for storing Windows credentials, which are
required for automating tasks that involve interacting with the Windows operating system, services, or
applications. Windows credentials consist of a username and password.

- Certificate: This asset type is used for securely storing certificates, typically for purposes like SSL
certificate authentication. Certificates are used for securing communication with web services and
websites.

- Generic Credential: Generic credentials can be used to store various types of sensitive information,
not limited to usernames and passwords. You can customize the fields to store relevant data securely.

2. Non-Credential Assets:

-Text: Non-credential text assets can store plain text data, such as API keys, configuration settings,
connection strings, or any other type of textual information. These assets can be used in your
automation processes to access and use the stored data.

- Integer: Integer assets are used to store numerical values as assets. They can be useful for
configuration settings that involve numeric values.
 - Bool (Boolean): Boolean assets are used for storing true or false values. You can use these assets to
control the flow of your automation based on specific conditions.

- URL: URL assets are used to store web addresses or URLs. You can use them for navigating to web
pages or interacting with web services in your automation processes.

- Key/Value Pair: Key/value pair assets store structured data in the form of key-value pairs. This allows
you to store and retrieve structured data in your automation workflows.

Q.15 What is a process? How can you deploy a process in Uipath?

In UiPath, a "process" refers to an automation workflow created in UiPath Studio, typically in the form
of a .xaml file. This workflow defines the series of steps or actions that a robot needs to perform to
complete a specific task or automate a business process. A process can include activities, data
manipulation, decision-making, and interactions with applications, systems, and data sources. The goal
of a process is to automate tasks, reduce manual effort, and improve efficiency.Here's an overview of
how you can deploy a process in UiPath:

Deployment of a UiPath Process:

1.Publish the Project:

- In UiPath Studio, you need to publish the project to a specified location. This generates a project
package that includes the workflow (.xaml) files, dependencies, and configuration files.

- To publish a project, open the project in UiPath Studio, click on the "Publish" button, and select the
appropriate Orchestrator or file system location where you want to publish the package.

2.Connect to Orchestrator (if applicable):

- If you are using UiPath Orchestrator to manage your automation, you need to ensure that your
UiPath Studio is connected to Orchestrator. This is where you define the Orchestrator URL and configure
the connection.

3.Upload the Package to Orchestrator (if applicable):

- If you are using Orchestrator, you can upload the published package to Orchestrator. This can be
done through the Orchestrator web interface. The package is typically uploaded to a specific process
package feed.

4.Define the Process in Orchestrator (if applicable):

- In Orchestrator, you need to define a process. This involves specifying the package, the environment,
and the type of robot that can execute the process. You also set parameters and input data if necessary.

5.Create a Release (if applicable):

 - In Orchestrator, you can create a release that includes one or more processes. A release is a
versioned set of automation processes that can be deployed to robots.

6.Allocate Robots (if applicable):

- In Orchestrator, you need to allocate robots to the process or release. This determines which robots
are authorized to execute the automation.

7.Schedule the Process (if applicable):

- If you want to run the process at specific times or intervals, you can schedule it in Orchestrator. This
allows for unattended automation.

8.Run the Process:

- Once the process is deployed, you can manually trigger it to run from Orchestrator, or it can be
automatically scheduled to run at specific times or in response to certain triggers.

9.Monitor and Manage Execution:

- Orchestrator provides monitoring and management capabilities. You can track the progress of the
process, view logs, and handle exceptions if they occur.

10.Update and Redeploy (as needed):

- If you make changes to your process, you should republish, upload, and deploy the updated package
to ensure that the latest version is executed by robots

Q.16 How Orchestration Server is used to control bots? Explain.

1.Bot Deployment and Management:

-Bot Registration: Bots are registered and onboarded into the Orchestration Server. Each bot is
associated with specific hardware and software configurations.

-Bot Authentication: Bots are securely authenticated to ensure that only authorized robots can
interact with the Orchestration Server.

2.Orchestrating Bot Activities:

- Task Assignment: The Orchestration Server assigns tasks or processes to available bots based on
predefined rules and priorities. These tasks can be routine, rule-based activities that are typically time-
consuming when performed manually.

-Queue Management: In the case of queue-based processing, the Orchestration Server manages work
items, assigns them to bots, and monitors the status of each item as it progresses through the
automation process.
3.Scheduling and Prioritization:

- Task Scheduling: The Orchestration Server allows administrators to schedule bot activities at specific
times, intervals, or in response to events. This helps optimize resource utilization and load balancing.

-Priority Management: Bots can be assigned different levels of priority for tasks, ensuring that critical
or time-sensitive work is completed first.

4.Error Handling and Exception Management:

- The Orchestration Server monitors the execution of tasks by bots and handles exceptions or errors
that may occur during automation. It can trigger predefined error-handling procedures or alert
administrators when issues arise.

5.Logging and Auditing:

- The Orchestration Server maintains comprehensive logs of bot activities. This audit trail helps in
tracking the progress of tasks, troubleshooting issues, and ensuring compliance with regulatory
requirements.

6.Load Balancing:

- The Orchestration Server can distribute tasks among available bots to balance the workload. It
ensures that bots are utilized efficiently and that tasks are completed in a timely manner.

7.Resource Allocation and Scalability:

- It allows administrators to allocate bots to specific tasks or departments, making it easier to manage
resources in large-scale RPA deployments.

8.Security and Access Control:

- The Orchestration Server enforces access control and security measures to protect sensitive data and
ensure that only authorized users and bots can access and execute tasks.

9.Integration and Reporting:

- It often offers integration capabilities to connect with other enterprise systems, databases, or
external applications. This integration enables end-to-end automation of complex business processes.

- Reporting and analytics features allow administrators to gain insights into the performance of bots
and the efficiency of the automation processes. Data and metrics can be used for continuous
improvement and optimization.

10.Scaling and Redundancy:

- For high availability and scalability, the Orchestration Server can be configured to run in a clustered
or redundant setup, ensuring uninterrupted bot management and task execution.
Q.17 How Orchestration Server is used to deploy bots?
1.Bot Deployment and Management:

-Bot Registration: Bots are registered and onboarded into the Orchestration Server. Each bot is
associated with specific hardware and software configurations.

- Bot Authentication: Bots are securely authenticated to ensure that only authorized robots can
interact with the Orchestration Server.

2.Orchestrating Bot Activities:

-Task Assignment: The Orchestration Server assigns tasks or processes to available bots based on
predefined rules and priorities. These tasks can be routine, rule-based activities that are typically time-
consuming when performed manually.

- Queue Management: In the case of queue-based processing, the Orchestration Server manages work
items, assigns them to bots, and monitors the status of each item as it progresses through the
automation process.

3.Scheduling and Prioritization:

- Task Scheduling: The Orchestration Server allows administrators to schedule bot activities at specific
times, intervals, or in response to events. This helps optimize resource utilization and load balancing.

- Priority Management: Bots can be assigned different levels of priority for tasks, ensuring that critical
or time-sensitive work is completed first.

4.Error Handling and Exception Management:

- The Orchestration Server monitors the execution of tasks by bots and handles exceptions or errors
that may occur during automation. It can trigger predefined error-handling procedures or alert
administrators when issues arise.

5.Logging and Auditing:

- The Orchestration Server maintains comprehensive logs of bot activities. This audit trail helps in
tracking the progress of tasks, troubleshooting issues, and ensuring compliance with regulatory
requirements.

6.Load Balancing:

- The Orchestration Server can distribute tasks among available bots to balance the workload. It
ensures that bots are utilized efficiently and that tasks are completed in a timely manner.

7.Resource Allocation and Scalability:

 - It allows administrators to allocate bots to specific tasks or departments, making it easier to manage
resources in large-scale RPA deployments.

8.Security and Access Control:

- The Orchestration Server enforces access control and security measures to protect sensitive data and
ensure that only authorized users and bots can access and execute tasks.

9.Integration and Reporting:

- It often offers integration capabilities to connect with other enterprise systems, databases, or
external applications. This integration enables end-to-end automation of complex business processes.

- Reporting and analytics features allow administrators to gain insights into the performance of bots
and the efficiency of the automation processes. Data and metrics can be used for continuous
improvement and optimization.

10.Scaling and Redundancy:

- For high availability and scalability, the Orchestration Server can be configured to run in a clustered
or redundant setup, ensuring uninterrupted bot management and task execution .

Q.18 Explain License management?

License management in the context of software and technology refers to the practice of overseeing,
controlling, and optimizing the allocation and usage of software licenses within an organization. Proper
license management is essential to ensure compliance with software vendors' terms, optimize costs,
and efficiently manage software assets. Here's an explanation of license management:

Key Aspects of License Management:

1.License Procurement:

- This involves acquiring the necessary licenses for software applications and tools. Organizations
purchase licenses from software vendors or authorized resellers based on their needs and the specific
software products they plan to use.

2.License Tracking and Inventory:

- Keeping a comprehensive inventory of all software licenses owned by the organization is a critical
step. This includes details such as the number of licenses, license type (e.g., individual, volume,
concurrent), version, and expiration dates.

3.License Compliance:

- Ensuring compliance with software vendors' licensing agreements is crucial. License managers need
to understand and adhere to the terms and conditions outlined in software licenses, which can include
restrictions on usage, redistribution, and the number of users or installations.
4.Software Deployment and Usage Monitoring:

- License managers track the deployment and usage of software within the organization. This includes
monitoring the number of installations, users, and concurrent usage to ensure compliance.

5.License Optimization:

- Optimizing licenses involves ensuring that the organization is using its licenses efficiently. This may
include reclaiming unused licenses, reallocating licenses as needed, or purchasing additional licenses to
meet demand.

6.License Renewal and Maintenance:

- Managing license renewals to avoid lapses in software coverage is an essential part of license
management. It also involves keeping software up-to-date with the latest versions and patches, as well
as maintaining support and maintenance agreements.

7.Cost Control and Budgeting:

- License managers are responsible for managing the costs associated with software licenses. They
need to budget for license renewals, monitor license spending, and look for cost-saving opportunities.

8.Vendor Relations:

- Building and maintaining relationships with software vendors is important. License managers may
negotiate licensing agreements, resolve issues, and seek discounts or favorable terms when renewing
licenses.

9.Compliance Audits:

- Organizations may undergo software license compliance audits by software vendors. License
managers need to prepare for and respond to these audits, ensuring that the organization is using
software legally and according to licensing agreements.

10.Centralized License Management Tools:

- Many organizations use specialized software tools for centralized license management. These tools
help track licenses, deployments, and usage, providing insights and automation for effective license
management.

11.Employee Training and Awareness:

- Educating employees about the organization's software usage policies and the importance of license
compliance can help prevent unintentional violations.

Q.19 How will you publish and manage updates? Explain.

Publishing and managing updates for software or applications involves a structured process to release
new versions, features, enhancements, and bug fixes to users or customers. This process is crucial for
maintaining and improving software, ensuring security, and meeting user expectations. Here's an
explanation of how to publish and manage updates:

Publishing Updates:

1.Version Control:

- Implement version control for your software using a system like Git. Each significant change should
be tracked with version numbers, such as semantic versioning (e.g., X.Y.Z), where X represents major
changes, Y represents minor changes, and Z represents patches or bug fixes.

2.Release Planning:

- Plan and prioritize updates based on user feedback, feature requests, bug reports, and the software's
development roadmap. Define what each update should include.

3.Development and Testing:

- Develop new features or fix bugs according to the update plan. Conduct thorough testing, including
unit testing, integration testing, and user acceptance testing to ensure that the update is stable and
functional.

4.Quality Assurance (QA):

- Engage QA teams or individuals to perform quality assurance testing. They should test the update
under various scenarios to identify and report any issues.

5.User Testing (Optional):

- If applicable, involve a group of users or beta testers to try out the update. Their feedback can be
invaluable for making final adjustments and bug fixes.

6.Documentation:

- Update or create documentation for the new features and changes. User manuals, release notes, and
help guides should be updated to reflect the new version.

7.Version Number Increment:

- Increment the version number based on the type of update (major, minor, patch) following your
version control system. Update the version information in your software code and documentation.

8.Packaging:

- Package the update in a format suitable for distribution. Common formats include executable
installers, software packages (e.g., .deb, .rpm), or container images, depending on the platform.

9.Release:
 - Publish the update through your chosen distribution channels, such as your website, app stores, or
software repositories. Ensure that users can easily access and install the update.

Managing Updates:

1.*Communication:

- Notify users about the availability of the update. This can be done through in-app notifications, email
newsletters, social media announcements, or messages on your website.

2. Automated Updates (if applicable):

- If your software supports automatic updates, inform users about the availability of the update and
allow them to opt for automatic installation. Ensure that the update process is seamless and reliable.

3.User Assistance:

- Provide clear instructions for users on how to download and install the update. Offer help and
support resources in case they encounter issues.

4.Feedback Collection:

- Encourage users to provide feedback on the update. Create mechanisms for collecting feedback, such
as surveys, support tickets, or community forums. Use this feedback to identify and address any post-
update issues.

5.Monitoring and Issue Tracking:

- Continuously monitor the software's performance after the update. Track issues, bugs, and user
complaints, and prioritize their resolution.

6.Patch Releases:

- If critical issues are identified post-update, prepare and release patch updates promptly to address
these issues. This demonstrates a commitment to resolving problems quickly.

7.Rollback Plan:

- Be prepared for the possibility of a major issue that requires a rollback. Have a rollback plan in place
to revert to the previous version while maintaining data integrity.

8.Iterative Improvements:

- Gather insights from user feedback and the software's performance to plan subsequent updates.
Continuously iterate to enhance features, address issues, and align with user expectations.

9.ecurity Updates:
 - Regularly release security updates to address vulnerabilities and protect users from potential threats.
Keep the software secure by staying informed about security best practices.

10.Long-Term Support (LTS):

- Consider offering long-term support for specific versions of your software, especially for enterprise
or business users who may require stability and continuity.

Q.20 How packages are managed in UiPath? Explain.

In UiPath, packages are a fundamental component of managing automation projects and activities.
Packages contain reusable automation assets, workflows, and libraries. Managing packages efficiently is
crucial for maintaining, sharing, and updating automation solutions within your organization. Here's an
explanation of how packages are managed in UiPath:

1. Package Creation:

- Packages are typically created in UiPath Studio, where you develop automation projects. You can
create a package by packaging a specific set of workflows, activities, and dependencies that make up a
reusable automation solution.

2. Package Versioning:

- Each package is assigned a version number, allowing for proper version control. UiPath follows
semantic versioning (e.g., X.Y.Z), where X is for major changes, Y is for minor changes, and Z is for
patches or bug fixes. Version numbers help you track changes and compatibility with other processes
that use the package.

3. Publishing Packages:

- Once a package is created or updated, it can be published to the UiPath Orchestrator or a local
package feed. Publishing makes the package available for distribution to robots or other users who need
access to it.

4. Orchestrator Integration:

- UiPath Orchestrator is a central component for managing packages in an enterprise environment. It

provides a central repository for storing, distributing, and managing packages.

5. Package Feeds:

- Orchestrator offers the concept of package feeds, which are like repositories where packages can be
stored and accessed. There are different types of package feeds, such as Tenant-level feeds, Host-level
feeds, and the default Orchestrator feed. Feeds can be organized by environments, tenants, or projects.

6. Package Deployment:
 - Orchestrator can deploy packages to robots, making them available for execution. The deployment
process ensures that robots have access to the correct version of the package to execute automation
tasks.

7. Package Management in Orchestrator:

- Orchestrator provides a web-based interface for managing packages. Administrators can upload,
manage, and monitor packages. They can assign packages to specific environments or processes and
ensure that the correct version is deployed to the associated robots.

8. Version Control and Rollback:

- Orchestrator allows for version control and easy rollback. You can select which version of a package
should be deployed to robots and revert to a previous version if issues arise.

9. Dependencies Management:

- Packages may have dependencies on other packages or libraries. Orchestrator manages these
dependencies and ensures that the required dependencies are available when a package is executed.

10. Package Feeds Security:

- Orchestrator provides role-based access control for package feeds. You can control who has access
to specific feeds and packages, ensuring that sensitive automation assets are secured.

11. Licensing and Compliance:

- Orchestrator can help manage licensing and compliance. For example, it can enforce licensing terms
and ensure that packages are used within the scope of their licensing agreements.

12. Package Updates:

- When a package is updated or a new version is released, Orchestrator can automate the process of
updating robots to use the latest version of the package.

13. Logging and Monitoring:

- Orchestrator provides logs and monitoring capabilities, allowing you to track the deployment and
execution of packages, ensuring that they run as expected.

4. Automation Lifecycle:

- Package management is an integral part of the automation lifecycle. It allows organizations to

develop, test, deploy, and update automation solutions efficiently.

Effective package management in UiPath is critical for maintaining consistency, version control, and
security in your automation projects. It helps organizations ensure that robots have access to the right
automation assets and that updates and changes are managed and tracked effectively.
Exercise Questions
Q.1 What are the best practices considered while working on a project? Explain.

Q.2 How exception handling can be useful? Explain

Q.3 How to nest a workflow inside a single workflow? Explain with an example.

Q.4 What are the different methods of reusing workflows? Explain.

Q.5 How to use comment in a workflow? Which activity is used for commenting? Explain.

Q.6 Write a short note on state machine.

Q.7 When to use Flowcharts, State Machines, or Sequences? Explain.

Q.8 How to use config files? Give an example of a config file.

Q.9 How will you integrate a TFS Server? Explain.

Q.10 How will you publish a workflow in UiPath? Explain.

Q.11 How to writing/edit the published package info into the .json file? Explain.

Q.12 What are the logical components of UiPath Orchestrator?

Q.13 What are Queues in UiPath? What are various activities that support this feature?

Q.14 What are the different types of Assets? Explain.

Q.15 What is a process? How can you deploy a process in UiPath?

Q.16 How Orchestration Server is used to control bots? Explain.

Q.17 How Orchestration Server is used to deploy bots?

Q.18 Explain License management.

Q.19 How will you publish and manage updates? Explain.

Q.20 How packages are managed in UiPath? Explain.