Process Design in RPA
1.1 Introduction
This white paper will showcase guidelines that can be used while
designing business processes so that all the common architectural concerns are
taken care of and the overall process design is robust and agile enough to
withstand changes with minimal impact on development and testing.
1.2 Benefits of having a good design
- Consistency: All designs contain similarly recognized granularity.
- Efficiency: How much of the process will be automated.
- Productivity: Fewer exceptions more productive process
- Performance: Process Design will work as fast as possible. (Minimize License requirement)
- Scalability: Designed to Scale-up without further development.
- Resilience: Ability to keep processing without manual intervention and unnecessary exceptions.
- Data Integrity: Elimination of risk of duplicate or orphaned cases due to recover-ability built into Design.
- Speed to production: Faster development and design to accommodate the local test approach.
- Re-usability: Object designed to support system and not the process so can be reuse across.
- Data Security: Designed to respect data security rules.
1.3 Common Scenario
1.4 Guidelines
1.4.1 Focus on Modularity
1.4.1.1 Modular design for a Process
The problem
with the above design is that, if there is any change in the login module, both
modules must be changed, and the same change must be repeated in any module
that has the login step. This will also impact the test-ability of the entire
process, any change in the login procedure will lead to the same changes being
made in both
1.4.2 Atomic Process Design
All process designs should be atomic, if any process is changing the
state of an application it should be atomic, meaning the change of state should
be complete, if it fails midway, the process should be able to reverse the
state of the application to the original state.
1.4.2.1 Atomic Process Design for a Process
While developing the module for New order creation effort should be made
that process can be subdivided into a sub-page which will specifically cater to
new order creation activity. This will act as a logical grouping, not just
logically but even functionally it should only house steps that are directly
1.4.2.2 Atomic design for objects
Objects should be created with atomic actions. Actions should be having
complete responsibility for one single functionality only. This ensures that
the action created is modular and reusable in every scenario. Once an action is
executed it should complete one atomic functionality for which the action has
been created.
1.4.3 Process Idem-potency
Idem-potency in
1.4.3.1 Idem-potency in Process
1.4.4 Central Controlling Authority
A Central Controlling Authority comprising of Technical Architects,
- Creates and enforces coding standards across the project.
- Duplication of components is avoided.
- Results in the creation of consistent code across the project, which increases maintainability.
- The components created are in sync with the overall design structure of the project and are more efficient and robust.
- Reduces turnaround time for development as every component’s design and scope is clearly defined.
- Easier to upgrade components due to common coding standards across the project.
- Cross-training resources are easy.
1.5 Conclusion
Following the guidelines mentioned in this white paper will ensure that
your
- Scalability – Architecture framework will be able to handle scalability as processes and objects created following the modularity approach ensure that they can be reused at scale without requiring any code change.
- Recoverability – Processes and objects with just single functionality/responsibility are easier to recover when crashed, exception handling is implemented in the the best possible manner in such an architecture.
- Security – From a security viewpoint as well single functionality architecture works the best as a process or object will only access data or application for which it has been designed as it does not overlap functionality or scope for any other role.
- Maintainability – Architecture following modularity principle is the easiest to maintain as any code change impact is limited to single functionality only, which makes not just the development easier but also regression testing is limited to a module only. So, the overall turnaround time and effort spent is considerably less.
1.6 Tool Specific Approach
1.6.1 BluePrism Appendix
1.6.1.1 Modular Design for Processes
Another benefit of practicing this approach is that the main page of the
process irrespective of how simple or complex automation it attains to, remains
readable and clutter-free thereby increasing the code readability and
understand-ability of the process, which in turn makes it easy for
up-gradations and enhancements in the future.
As you can see from
the screenshot, stages about actions that can be tied together logically have
been moved on to a sub-page e.g. Start-Up, Populate Queue, Generate Order, etc.
This increases the cohesive nature of the process and provides a much-needed
the option of re-usability to the sub-pages. It also encapsulates the business
logic/rules from the main page making it easier to understand the complete flow
of the end to end business process.
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------
