RPA - Enforcing Coding Standards

With Robotic Process Automation gaining momentum, organizations big and small are rushing to invest in this technology with expectations of quick returns. While there is no doubt a well-executed RPA project can bring in quick returns, if not tread carefully, teams might be setting themselves up for failure.

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.

 Let's looks at one of the challenges at hand 'RPA - Enforcing Coding Standards' and a possible solution (if done proper)

 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
• 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?

Instill 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 upto 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.