Skip to main content
Version: 10.3.2

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 and 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 or 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, and so on.

High demand in a technology or tool attracts a lot of talent. Especially when the technology and tool claims to be low or 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, and so on, 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 and 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, and 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 a 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. 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.