Unleash Scalability: How Appian Executes 6 Million Processes Per Hour

Appian is the process company. For more than 25 years, industry-defining organizations have turned to Appian to orchestrate their most important processes. But we never rest on our laurels. Part of our latest release, our process execution service sets a new standard for scalability. 

Autoscale combines low-code design and business process automation with unmatched scalability. IT teams using Autoscale don’t have to worry about orchestrating dynamic cloud infrastructures, developing Kubernetes operators, standing up scalable data stores, or orchestrating a complex sea of microservices just to achieve higher process throughput. Appian handles it all. Now, developers can run their organizations' most complex processes in our massively scalable process execution architecture.

Autoscale doesn’t operate in isolation. Like everything else in Appian, it’s part of an interconnected process platform with process models at the center. The Appian Process Modeler lets you lay out workflows visually, like a flowchart, then it lets you execute them from right there in the platform.

Low-code developers can add smart services like external system integrations and AI directly to process models in Appian. Each smart service includes a set of input parameters, a central operation, and outputs. This standard “Input, Operation, Output” paradigm lets developers add new smart services to processes without needing to learn novel configurations. 

For example, AI Skills are a type of smart service in Appian. The email classification AI Skill requires two inputs: an email document and a confidence score threshold, set by the developer. After it receives those inputs, the AI Skill outputs a classification decision and a confidence score. If the confidence score is above the threshold set by the developer, the email gets processed straight through. If the confidence score is below the threshold, the process routes to a human for verification.

Appian processes interact with each other in complex ways: 

• Processes can start sub-processes synchronously or asynchronously, and developers can control the parent process’s behavior when sub-processes execute. 

• Using Appian multi-node instances (MNIs), a process can loop over an itemized list of data and initiate a sub-process per item. And developers can control the child process sequencing by running, for example, serial or parallel execution. 

• Appian processes can loop back to earlier steps, allowing them to repeat actions or recheck conditions when needed. 

• Processes can send messages to other processes, update or cancel in-flight processes, and perform advanced operations often missing in basic workflow modeling tools provided by other vendors.

To enable Autoscale, a developer simply checks a box in the process model properties. When Autoscale is enabled, the Appian Process Modeler adjusts the palette of available smart services. See the example process model for managing a high volueme of insurance claims below. Not all smart services are available at extremely high process volumes, but operations like integrating with external systems, reading from or writing data to databases, and even performing data transformations are all supported.

But what if you want access to all the smart services available in Appian, like assigning a user input task? Actions like assigning human tasks aren’t practical for processes running millions of times an hour. But Autoscale and non-Autoscale processes are interoperable—one can trigger the other, and vice versa. So when a human needs to get involved, an Autoscale process can trigger an exception flow process that doesn’t use Autoscale.

Take our insurance claims management example. In the process model, a decision to escalate a claim triggers an exception flow process. The exception process doesn’t use Autoscale, so all the operations needed to resolve the claim, like assigning user tasks and sending emails, are once again available in the smart services palette.

And Autoscale processes can stem from non-Autoscale processes, too. Autoscale processes can start via API or end user interaction, or they can be processed in batches of transactions from a message queue—using a multi-node instance (MNI), a non-Autoscale process can loop over a batch of messages and trigger an Autoscale process for each item. 

So Appian lets you build complex, high-throughput processes without complex development work. What’s next? Once you have your high-throughput process running with Autoscale, Appian will help you monitor it.

Appian lets you monitor, inspect and debug processes, whether they’re running, paused on an exception, or completed. You can monitor Autoscale processes by using filters and summaries to display high volumes of data efficiently.

The process monitoring dashboard for Autoscale processes shows error rates compared to start rates at the top, helping you quickly spot disruptions or inefficiencies. 

The main grid aggregates process information by process model and reports key details, including:

• Number of processes started versus total number queued

• Total completed processes versus total errored

• Average completion time per process

By drilling down into a process, you can view more execution data, including:

• Start time

• End time

• Time in queue

• Processing time

There are also filters to identify processes from a specific span of time or show errored processes only. You can open each process instance to see how it was executed, with clear highlights overlaid on the model to show the flows and nodes it followed.

Every Appian process has a process definition that describes its smart services, process flows, node configurations, variables, and all the other details that define it. When an Autoscale process starts, Appian loads this definition into a containerized Java Virtual Machine (JVM), which executes the business logic described in the definition and performs other necessary process work, such as calling integrations, evaluating rules, and committing data changes. Let’s call this JVM an “actor.” 

Autoscale uses algorithmically driven horizontal scaling, creating more and more actors to handle higher and higher process volumes. Appian Cloud’s Kubernetes-native architecture allows for scaling containerized deployments of actors to execute extreme volumes of process work. 

If processes were stateless—that is, if they didn’t need to retain data—then we’d be done explaining how they scale. But processes are not stateless; they are stateful. They must retain information, like process variables and progress, and actors must be able to access it. To account for this, Autoscale actors retrieve process information from a shared external data system. Any actor can access process information from this data system, even if it didn’t start that process. This, along with memory caching and our serial processing algorithm, lets Autoscale handle high-throughput processing with ease.

Close readers may have noticed process queueing mentioned in the process monitoring section of this blog. Autoscale leverages internal messaging services to queue and partition work for highly efficient parallel process execution via a first in, first out (FIFO) scheduling method. Actors continuously poll these queues for new work, with at most one actor per queue partition, ensuring smooth and balanced workload processing.

With Autoscale, Appian handles the container orchestration, horizontal scaling, data persistence, and microservices, so your busy IT teams can put their minds to better use.

IT teams must be smart about the problems they invest time into solving. Autoscale tackles the complexity of extreme-scale process execution, so your workers are free to focus on modeling and automating the needs of the business, no matter how frequently those needs change.

To learn more about Autoscale and all our latest capabilities, please watch the 24.4 webinar replay.