Agree and follow unified solution standards

There are many strategic recommendations are issued on how to structure RPA programs to achieve advanced Robotics, particularly on how to:

build RPA Framework
shape RPA capabilities
streamline Roles & Responsibilities within RPA project
enhance change management function throughout RPA journey
apply Lean and Agile in RPA projects

However not much said and explored on what the technical pitfalls are and what actions are to be taken to ensure that your RPA project on a right track. Thus, we find it crucial to list some key technical pitfalls you might be facing with during your RPA journey in order to get you better prepared to deliver on promise of RPA. The list is not definitely complete as many challenges rising up on your way would be coming from the specific environment you would be working in and stack of technologies / platforms you would be utilizing in your RPA project. The list of most common tech pitfalls is below but not limited to:

RPA coding standards and principles

No matter which RPA platform you would be utilizing or how big is your development team – it is very critical to agree upfront within your dev team on coding standards and principles to ensure your Bot Task code is consistent and accurate across. This is not a discovery as this is a standard approach applied in software engineering world. Considering the fact that creating a Bot Task is also a part of the automation – respectively all basic principles used for classic automation are to be also applied for robotic process automation: DRY (Don’t Repeat Yourself), naming conventions, naming variables, commenting, portability, etc.

High demand in a technology or tool attracts a lot of talent. Especially when the technology/tool claims to be low/no code, drag-drop types, the influx of people into the technology is multi fold. Folks with varying skillsets, backgrounds and experience (sometimes with little exposure to technology delivery) quickly learn the tools missing out on real time experience in technology delivery. This creates a bigger problem if not managed.

Code quality

While providing sufficient training on the RPA tools and technology enables a resource to create automated processes in relatively short time, some key factors that often gets overlooked in rapid BOT development is design, code quality and maintainability. This could become a bottleneck with even the slightest changes in the underlying application or process that is automated.

Importance of coding standards and code review in software development

Helps improve the quality of the overall software system
Reflect a harmonized style, as if a single developer wrote the code in one session
Reflects not only the software but the organization itself
Improved maintainability of code
Limits risk and improves code quality
Helps all developers to be familiar with the code structure

When talking coding standards, we can say the best and effective way of enforcing that is through code reviews, by having a developer review the work done by other developer. But does it really solve the problem when it comes to RPA in rapid agile development teams? Let's look at some of the challenges

Challenges of enforcing coding standards and strict code review practices

Time in understanding process and complex flows created by a developer
Blur lines on what to consider for review
Fear of reviewing and being reviewed
"Imposter syndrome" - is a psychological pattern in which an individual doubts their accomplishments and has a persistent internalized fear of being exposed as a "fraud"
Stress in a high pressure environment due to the additional overhead of someone else's code review
Possible delay to committed timelines due to multiple iterations of code review
Unavailability of code review tools and level of customization

Most of you might be able to connect with the above mentioned challenges. The process is vague and monitoring this practice becomes impossible as teams grow in size. Alright, so what does actually work?

Coding discipline

Common templates with predefined customizable sections. Create a common standard. Most of the processes coming through your BOT shop will definitely follow a set of sequences, like initialization, cleanup, queue processing, error processing, etc. make these into a template to be used by all processes. This should be the first step in creating a standard for developers.

Extensive coding standards document and boot camps for new developers. Document best practices and coding standards preferably as checklists with clear examples. Organize boot camps for new developers joining the team to get them up to speed with the standards and practices

Compulsory developer forum attendance. Setup recurring developers meet to ensure everyone are on track, discuss problems/solutions and revise standards. Make everyone involved and encourage contribution.

Look at the goal. Why should one code well? Find the target audience who will maintain the code. Ultimate goal is to create a maintainable code, so others can easily follow what one developer has coded. Always encourage developers to have this mindset

Enhancement team involvement in testing and in-turn code review. Depending on the operating model of your RPA program, an Enhancement team is most likely in the mix. These are folks who maintain/scale/fix code while the developers move on automating new processes. A good strategy is to make a practice of testing and code sign off by enhancement team who can enforce coding standards and eventually responsible for maintaining the code. This saves time for handover and helps better transitions.

To conclude.. While enforcing extensive code reviews and coding standards can work. In a high performing, rapid development teams, it is instilling coding discipline that accelerates growth. Take time upfront to create process templates for common tasks and setting guidelines for everyone to follow.

RPA programming methods

There are two key programming methods applied for creating the Bot Task: UI (User Interface) and Background Programming. Before creating your Bot Task Structure and Bot Task Flow, you definitely need to question yourself which programming method would be applied for particular process. Selecting the most appropriate one will directly depend on the RPA platform you would be utilizing, third party applications capabilities you would be dealing with, process and environment peculiarities as well as your customer’s requirement on how end user wants to see particular Bot Task processing the data: either on background or UI.

RPA business continuity

What could be the worse than losing all your works (created code) on a day you need go to prod? It’s really frustrating to see that your created code was lost due to inefficient set up on backing up your data. RPA development environment shall be set to provide 100% guarantee for source-code repository availability and consistency in order to ensure business continuity throughout your RPA project. Literally speaking, when your RPA dev team develops the Taskbots - all source-code that is being placed in Repository shall be stored on the redundant data-store which is properly backed up (or snapshots taken) in reasonable time-intervals (for example, every hour).

RPA code control framework

Version Control System (VCS) (for example, SVN or Git) is a backbone of any software development project, including an RPA one. With no VCS properly integrated in your RPA development setup, you will face inconsistency and quality issues with your deliverables. This will also require extra efforts of your senior RPA developer to pull development outputs together to deliver the results. Thus, while setting up your RPA dev environment, it’s highly recommended to set up a VCS in your RPA control room before you kick off your dev works.

RPA transition code principles

This would not be a surprise if you customer would tell you on certain stage that your Dev, QA and Prod environments are different. In order to manage this challenge - you would simply need to use Data Stores where all variables are stored to manage differences between environments more efficiently.

The listed above pitfalls are the tip of the iceberg and to make sure that your RPA output is manageable, delivered in time and with a highest quality - you don’t need to forget to have right people with right tech skills in your team to deliver on promise of RPA.