Tips to make better workflows using UiPath.

RPA is taking the world by storm. It allows the companies to automate mundane tasks so that their resources could focus on something more important. This is beneficial not only for the company but also allows the employee to get their hands dirty in other areas of the industry as well.

Tools such as UiPath not only allow us to create workflows that can range from simple to pretty complicated(depending upon business logic) but also allows us to do it very elegantly with a drag and drop mechanism.

Here are some of the tips that could help you to make your workflows more efficient-

#1: Using Global Variables.

If you have any experience in programming then you know the importance of global variables. While creating workflows we usually pass all the required variables as arguments to different workflows. The flaw with this approach is that if there is a small change in arguments of any one of the workflow then all other the workflows where it was called has to be modified.

Getter Setter Activity.

In the above demonstration notice that Import Argument = 0. This means the value in the invoked workflow is being picked from our global variable.

#2: Multiple Assign activity.

When dealing with initialization or assignment of multiple variables we usually tend to a simple Assign activity. This leads to a cluster of activities that can be a bit overwhelming to look at.

For such cases use Multiple Assign activity. It allows us to assign values to multiple variables in one go.

Assign Activity vs Multiple Assign Activity

#3: Finding common and uncommon values between the two lists.

Many times we are facing a situation where we need to extract common or uncommon values among 2 lists. For that, the usual approach is using a for loop with an if-condition activity to determine common and uncommon values.

Intersect() method Syntax
Except() method Syntax
Extracting Commons and Uncommons via ForEach vs Intersect(),Except()

#4: Getting a list of files in a directory.

Often times while performing actions such as reading or writing on a file it is a good practice to check whether a file is already present in the directory or not and making the decision accordingly.

File.Exists() Syntax

Above returns a boolean which can be checked for the presence of the file.

File.Exists() Syntax

#5: Checking if some string is Empty or Null.

Usually, for this task, we go with the equality operator which needs to be used twice for both empty(“ ”) and Null. This approach is fine but String class provides us with a solid way of checking whether a string is empty or null in one go.

String.IsNullOrEmpty() Syntax.

This method returns a boolean which can be used for checking purposes.

#6: Merging multiple collections into one.

List<T> or any other collection type provides a method of add() to add value to an existing list. But if we want to add the content of another list then we need to do it one by one via add().

Concat() method Syntax

We have to add ToList() at the end as the resulting output of Concat() is of type IEnumerable() which is not as same as List(). So, the ToList() method converts it to the list.

#7: Sending keystrokes multiple times using a single activity.

When we need to send a hotkey in our application, we usually use Send Hotkey activity. The problem is when we need to send multiple hotkeys the number of activities also increase leading to the complex looking workflow.

Not only this, the keys usually have some delays in between as they are being sent via different activities which leads to an increase in bot’s processing time.

To reduce the repetition of such activities we can replace the ‘key’ property of Send Hotkey activity by this —

Syntax to send keystroke multiple times.

#8: Filtering data from DataTable.

While we do have Filter Datatable activity, it does not provide a lot of flexibility in terms of conditions and we cannot query data from multiple DataTables as well.

Syntax and Example of a Linq Query

The AsEnumerable() function converts the DataTable to an array of Rows and after we have selected the rows we need, CopyToDataTable() convert those back to a DataTable.

#9: If statements in assigns.

If a variable can get multiple values each depending upon a particular condition then the workflow might look like this:

Nested IF Activity.

And this might go on and on. But it’s not a good practice to have nested If activities.

If statements with Assign Activity.

#10: Formatting String.

While building a dynamic string you must have seen a lot of ‘+’ being used. This approach is good for small strings but is not ideal for larger ones.


Typical Dynamic Strings.

As we can see Example #1, dealing with short strings is not half bad but things get clumsy when we are talking about Example #2. Here I have formatted the string so that it is a bit easier to understand.

Syntax of String.Format() method

As we can see the text is written in running format and where we required value from any variable we substituted it with a place holder {variable_number}. It tells which variable to pick up from the list of variables mentioned in the end.

So our examples become —

Modified Examples with String.Format() implemented.

#11: Logging type.

This is a really basic one but its importance cannot be overstated. In UiPath we have 5 logging levels. Fatal, Error, Warning, Info and Trace. Each of these levels has its own significance.

When dealing with logs main issue we face is of immense data that is in front of us. If not done properly then logs could look like this —

Logging without setting up the levels.

But If we use proper levels for logging then we can achieve this —

Logging with proper usage of levels.

As it’s clear that we can easily identify the error logs now.

That’s all for now. If you have any more ideas feel free to mention in the comments.

Happy Automation!

Developer with keen interest in everything tech!