Application Tuning: Getting More from What You Already Have

Application tuning helps you maximize performance, responsiveness, and scalability of your existing Appian applications, without resorting to invasive, costly, and time-consuming design changes.

Application tuning techniques generally fall into two categories: 

• Invasive, involving requiring deep code or design changes 
• Non-invasive, involving configuration and environment adjustments

For Appian applications—whether hosted in Appian Cloud or self-managed—non-invasive tuning and scaling adjustments should be your first step toward achieving your performance goals. Consider these techniques recommended by our Customer Success team for fine-tuning your Appian environment before pursuing more complex changes. 

Generic tuning isn’t enough. Appian performance optimization requires a deep understanding of how its engines process data and handle read/write traffic.

• Add engine replicas. If users are experiencing delays while waiting for the system to process requests, adding engine replicas can significantly improve performance. Replicas help balance the "read" traffic across multiple instances, resulting in much faster response times and lower latency for your end-users.
• Add execution and analytics shards. Appian splits process data across "shards" to keep memory usage low and process work in parallel. If your execution engines are constantly working with no breathing room, expanding the number of shards can help distribute the load. (Note: Shards cannot be removed once added, so scale them deliberately.)

Fast applications start with fast data retrieval. In Appian, inefficiencies in application design can cause unnecessary stress on the platform.

• Evaluate record queries. If data retrieval is slow, focus on optimizing your interface designs and data queries. Much of the system's workload is dictated directly by how the application is built, meaning that refining your front-end design and query structures can dramatically improve application performance.

The interface is where your users feel the impact of tuning most directly. In Appian systems, a slow interface is rarely a lack of power; it is usually a result of complicated design that forces the system to do unnecessary work.

• Implement "passive" local variables. By default, Appian re-evaluates an entire interface whenever a user interacts with it. Use local variables with defined refresh configurations to "lock" data that doesn't need to change. This prevents expensive database queries from firing every time a user types a single character in a text box.

• Minimize data transfer with field-level selecting. When using Record Types, never pull the entire record if you only need two columns. Use the fields parameter in your queryRecordType calls to fetch only the necessary data. Reducing the payload size between the Appian engine and the user’s browser is the fastest way to lower latency on low-bandwidth or mobile connections.

Instead of over provisioning or dealing with monolithic servers, optimize your Appian infrastructure to handle user traffic and background tasks efficiently.

• Scale application servers. As user traffic increases, your application servers will require more memory and CPU to handle web requests, mobile app interactions, and background activities such as unattended processes and email polling. Deploying additional, smaller application servers can speed up background processing and increase your system's overall resiliency.

If background tasks are taking a long time to complete, the problem might be outside the Appian Platform.

• Verify external capacity. Bottlenecks are often due to overloaded downstream resources. Appian frequently connects to external integrations, web services, and enterprise directories. Ensure that these external systems are properly sized to handle the volume of requests generated by your Appian applications.

Application tuning is a continuous discipline of measuring, evaluating, improving, and learning.

• Prove the bottleneck. Avoid speculating on the root causes of performance degradation. Instead, use performance testing and comprehensive system-level monitoring to precisely identify the necessary scaling measure. Appropriate actions can include integrating dynamic Appian Data Server (ADS), enhancement of real-time stores (RTS), increasing the worker thread count, deploying supplementary application servers, or augmenting engine replicas.

• Assign tool owners. Ensure your team has a clear system configuration owner who understands the architecture and knows exactly when to escalate complex scaling needs to Appian Cloud support.

• Iterate gradually. Make one configuration change at a time (e.g., integrate ADS or increase RTS or worker thread counts), measure the impact, and adopt the change if it improves performance or roll it back if it doesn't.

The Appian Performance Engineering Center team, which created these techniques, is ready to put them to work for you. They provide the Appian Optimize service, so you can shift from reactive troubleshooting to proactive scaling. Identify, diagnose, and resolve bottlenecks before they impact your users. To start turning user experiences into operational wins, explore our Appian Customer Success offerings.