This page is about the features you can utilize when multiple collaborators are making updates to existing applications. It discusses how to apply the concept of Continuous Integration when building your Appian applications, and represents the first part of the DevOps pipeline.
Continuous Integration in Appian means updating your applications frequently and incrementally. The goal of this approach is to reduce the risk of making conflicting changes or a large number of changes all at the same time.
Appian facilitates this goal by providing features that will allow you to manage and keep track of changes throughout the application building process.
Appian objects work together to shape powerful and flexible applications. You can reference objects in multiple places in your application, such as calling an interface in a record. Reusing objects in applications allows you to quickly build functionality and easily maintain your applications. When improving and updating existing applications, designers should take into consideration how their changes will impact supporting objects in the application.
Appian provides tools that allows you to perform an impact analysis of related objects to make it easier to update your applications. We categorize these object relationships as dependents and precedents.
Dependents analysis shows all of the objects that reference the object you are changing. Think of this as the potentially affected radius of your change. You should test all the dependents of an object after making significant changes. You might also need to update the dependents for certain types of changes, for example, deleting a rule input that isn’t needed anymore.
Precedents analysis gives you a quick way to see and navigate between all the objects referenced by the selected object. In addition, this analysis gives you an easy way to identify all new precedents to add to your patch or application before deploying it.
You can also CTRL/CMD+click on an object’s name to open it from an expression.
Most Appian objects support versioning. Every time you update one of these objects, you create a new version of that specific object. It can be hard to keep track of all the changes to an object when multiple people are updating it. Appian allows designers to compare the latest version of the object with the previous versions, which helps you review and troubleshoot your versioned objects with greater speed and clarity.
Comparing object versions helps you better understand how the object has changed over time in a single environment. You can also compare application objects across environments to understand what changes you might want to deploy. Before you promote your changes to another environment, you should review the patch contents using this comparison capability. This will allow you to review the changes for every object in your patch and catch any required precedents that are missing from your patch.
Before testing and deploying your applications, take into consideration how your design decisions will affect users and future development. Appian Health Check is a great way to check that you’re following design best practices and find potential areas of improvement in your application. Appian Health Check covers four areas: Infrastructure, Configuration, Design, and User Experience.
Run Appian Health Check frequently throughout your application building process to view results for the entire environment. Appian recommends running Health Check at least once per sprint to receive regular feedback about design choices.
For more information about using Appian Health Check to monitor system resources, see Monitoring Applications.
Whenever you make a change to your application, you should always make sure it doesn’t affect any other processes or objects that rely on it. It is important to plan for backward compatibility and do regression testing to ensure that you can deploy with confidence.
On This Page