Appian ACD200 - Appian Certified Senior Developer

 The question is about troubleshooting slow response times on a SAIL interface. The following are two potential causes of the performance issues:

Multiple a!save operations: This means that the interface has multiple expressions that use a!save to store data in variables or update components. This can cause performance issues, as each a!save operation triggers a server round-trip and refreshes all dependent components on the interface. You should minimize the use of a!save operations and use local variables or component parameters instead.

Configuration of refresh variables: This means that the interface has components that use refresh variables to control when they should be refreshed based on changes in other components or variables. This can cause performance issues, as some components may be refreshed unnecessarily or too frequently due to incorrect or excessive refresh variables. You should optimize the refresh variables and use them only when needed.

The following are not likely causes of slow response times on a SAIL interface:

Multiple rule inputs: This means that the interface has expressions that use rule inputs to pass data or parameters to expression rules. This does not affect the performance of the interface, as rule inputs are evaluated on the server and do not cause additional server round-trips or refreshes.

Stacked button layout: This means that the interface has a layout component that arranges buttons in a vertical stack. This does not affect the performance of the interface, as it is a simple layout component that does not require any server interaction or refresh logic.

References:

a!save()

Refresh Variables

Rule Inputs

Stacked Button Layout

The best process model design for a case management application is to use a case record and a related action. This way, the process flow does not have to wait for the reviewer to complete the task, which can take up to 7 days. This reduces the memory impact of the process, as well as the risk of process timeouts or errors. The case record also provides a better user experience, as the reviewer can access the case details and the related action from one place. Therefore, the best answer is A.

References:

Case Management

Related Actions

References:

[Web APIs]

[Connected Systems]

[Expression Rules]

[Decision Tables]

The question is about designing a process model to store the result of an expression rule for every item in a list with the lowest memory footprint. The best design for this purpose is to configure a script task to use a!foreach to iterate over each item in the list, as it allows you to execute an expression rule for each element of an array without creating multiple nodes or subprocesses in the process model. A script task is a node that executes an expression without user interaction, and a!foreach is a function that applies an expression to each element of an array and returns an array of results. The other options are not optimal for this purpose, as they either create more nodes or subprocesses in the process model, which consume more memory and resources. References:

Script Task

a!foreach()

A joining table can be used to hold instances of Student/Class relationships, so that it can be supported in Appian and remain in at least First Normal Form. A joining table is a table that contains only foreign keys that reference the primary keys of other tables. A joining table can be used to model a Many-to-Many relationship between two entities, such as Student and Class. For example, a joining table called Enrollment could have two columns: Student_ID and Class_ID, which reference the primary keys of the Student and Class tables respectively. Each row in the Enrollment table represents an instance of a student enrolled in a class. References: [Joining Tables], [Many-to-Many Relationships], [First Normal Form]

The requirement is to find a list of expression rules that are causing performance issues, or have caused performance issues in the last 30 days. The best way to do this is to access the Rule Performance tab in the Administration Console, as it provides a dashboard that shows the execution time, frequency, and impact of expression rules in a given time period. You can filter the rules by application, rule type, or execution time, and sort them by various metrics. You can also drill down into each rule to see the details of its executions and test cases. The other options are not as effective or convenient for this purpose, as they either do not provide enough information, require manual inspection, or are not related to expression rules. References:

Rule Performance

Three possible reasons for high memory consumption of a process model are:

Too many process variables. Process variables are used to store data that is needed throughout the process execution. However, having too many process variables can increase the memory usage of the process engine, especially if the variables store large or complex data types, such as documents or CDTs. It is recommended to use local variables whenever possible, and to delete or nullify process variables that are no longer needed.

Nested CDTs with large numbers of fields. CDTs are custom data types that define the structure and validation of business data in Appian. CDTs can be nested within other CDTs to create complex data models. However, nesting CDTs with large numbers of fields can result in high memory consumption and performance degradation, as each field requires additional memory allocation and processing. It is recommended to limit the number of fields and nesting levels of CDTs, and to use references instead of embedding whenever possible.

Too many nodes. Nodes are the graphical elements that represent the activities and events in a process model. Having too many nodes in a process model can increase the memory usage and complexity of the process execution. It can also make the process model harder to read and maintain. It is recommended to simplify the process model by using subprocesses, smart services, or expression rules to encapsulate common or reusable logic. References: Process Variables, Custom Data Types, Process Model Best Practices

 Two places to get information on process model memory usage are:

Process monitoring tab. The process monitoring tab is a feature in the Appian Designer that allows you to monitor and manage the performance and status of process models and instances. You can use the process monitoring tab to view various metrics and statistics about your processes, such as memory usage, execution time, node count, error count, etc. You can also filter, sort, and export the data for further analysis. The process monitoring tab can help you identify which processes have the highest memory footprint and potential performance issues.

Appian Health Check report. The Appian Health Check report is a tool that provides insights into application design patterns and performance risks in your environment. The report covers four areas of your environment: design, user experience, infrastructure, and configuration. The report also includes graphs highlighting historical trends, such as user activity, average response times, and resource utilization. The Appian Health Check report can help you identify which processes have the highest memory consumption and suggestions for mitigating them. References: Process Monitoring Tab, Understanding the Health Check Report

The question is about the recommendations for Appian environment to address the performance risk of a large increase in users. The following are two recommendations for this purpose:

Add more process execution engines. This means adding more servers or nodes that can execute process instances in parallel, which can improve the scalability and availability of Appian. This can help handle the increased workload and demand from more users without affecting the response time or reliability of Appian.

Add more application server memory. This means increasing the amount of memory allocated to each server or node that runs Appian components, such as web servers, engines, or analytics servers. This can help improve the performance and stability of Appian by reducing memory pressure and garbage collection.

The following are not recommendations for Appian environment to address the performance risk of a large increase in users:

Add more design engines. This means adding more servers or nodes that can execute expression rules or interface components in parallel, which can improve the performance and scalability of Appian. However, this is not directly related to the number of users, but rather to the complexity and frequency of expression rules or interface components in the application.

Switch from a records-centric to a process-centric design. This means changing the application design to focus more on process models and tasks, rather than records and reports. This does not affect the Appian environment, but rather the application logic and functionality. This may or may not improve the performance of the application, depending on the requirements and use cases.

References:

Process Execution Engines

Memory Recommendations

Design Engines

Records-Centric vs Process-Centric Design

Three methods that could be used to launch a test run for expression rule test cases when required are:

A process model invoked via an API. A process model can be designed to run test cases for expression rules using the a!testRule() function or the Test Rule smart service. This process model can be exposed as a web API with an HTTP method such as POST or PUT, allowing external systems or applications to invoke it through an HTTP request.

A process model exposed to users as an action. A process model can also be designed to run test cases for expression rules using the same function or smart service as above. This process model can be exposed to users as an action on an interface, such as a button or a link, allowing users to trigger it manually when needed.

A SAIL interface embedded in a report. A SAIL interface can be created to run test cases for expression rules using the a!testRule() function. This interface can be embedded in a report, such as a grid or a chart, allowing users to view the test results interactively on an interface. References: Automated Testing for Expression Rules, a!testRule() Function, Test Rule Smart Service, Web APIs, SAIL Interfaces