I want to know what is the most effective strategy to handle old production processes that were designed with a methodology that involves extensive and long-lasting processes. In addition, we face numerous PRO issues that require quick solutions from the support team. Simultaneously, improvements are being made to extend or enhance the functionality of these processes. However, problems arise when we have to solve an issue that involves the modification of objects that are also being altered in the enhancements and are not yet stable. Another challenge is managing active instances with old versions of the flow; when trying to implement a new version of the process, conflicts can arise due to incompatibility between the old version of the instance and the new version of the process. Appian suggests a method in their documentation, but I find it has several limitations. I am interested to know how they handle these situations in other projects to learn from the best practices applied.
docs.appian.com/.../Process_Upgrade.html
Discussion posts and replies are publicly visible
After several days of consulting with various experts in the field, I have summarized the following recommendations for properly managing old productive processes that face problems and need updates in an environment where versions may be incompatible for various reasons:
Use of Certification or Release Candidate Environments: It is crucial to maintain a certification environment that faithfully simulates the production environment. This allows testing changes and solutions before their definitive implementation, helping to identify and solve problems without compromising the production environment. Here is a guide on what the ideal environment structure should look like: Recommended Environments.
Version and Change Management: Implementing rigorous control over versions and changes is essential. This includes techniques such as maintaining version control on common data types (CDT), which allow differentiating between old and new versions of a process. Although I personally find that this can complicate the code, it allows adjusting the process logic according to the specific version of the data.
Modularization and Encapsulation: Dividing the process into smaller, manageable components, such as subinterfaces, expression rules, and subprocesses, facilitates the implementation of changes without impacting other parts of the process. This strategy also helps prevent conflicts during implementations by allowing updates to specific parts of the process.
Specific Solutions for Urgent Problems: For urgent production problems, it is practical to first resolve these complications in an environment that shares the same code version as production (Release Candidate) and then implement the solution in the production environment. Subsequently, a task should be added to resolve the same issue in the development and pre-production environment as soon as possible.
Redesign Using New Features: New features of the platform should be leveraged to redesign processes that may be causing problems due to their duration or obsolete structure. Using records and related actions instead of long processes can significantly improve performance and manageability.
Coordination and Communication Among Teams: It is vital to ensure that there is good communication and coordination among development, support, and operations teams to ensure that changes are understood and managed appropriately by all involved.
I also found these links that explain how to do this.
community.appian.com/.../backward-compatible-design-planning-for-subsequent-deployments
community.appian.com/.../addressing-a-production-application-defect
Please feel free to add your opinions so that we can come to the most accurate conclusions together.
Best regards.
In this blog post, I describe my go-to solution for long running processes.
https://appian.rocks/2023/03/20/design-long-running-tasks/