ACD200 Appian Certified Senior Developer Questions and Answers

 A memory circuit breaker error occurs when an interface consumes too much memory on the server. This can happen when the interface is storing too much data in local variables or when the interface component is looping over too many items. Both of these scenarios can cause excessive memory allocation and garbage collection, which can degrade the performance of the interface and the server. Therefore, the possible root causes of this error are C and D.

References:

• Memory Circuit Breaker
• Performance Best Practices

 Creating a trigger on the database table to capture the audit trail to a table is the most efficient and has the least impact on the Appian application, because it avoids adding extra logic or calls to the Appian application, which could affect its performance and scalability. A trigger is a database object that automatically executes when a specified event occurs on a table or view. A trigger can be used to insert, update, or delete data from another table based on the changes made to the original table. References: [Triggers], [Audit Trail]

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

 The Number (Integer) data type should be chosen for the BOOK_ID, because it is a unique identifier for each book record. The Number (Integer) data type is used to store whole numbers without decimals, such as IDs, counts, or ordinal values. The Number (Integer) data type can also be used as a primary key for a CDT or a foreign key for referencing another CDT. References: [Number (Integer) Data Type], [CDT Primary Keys]

The question is about initiating a process via an Appian web API. The HTTP request method that the API should use is POST, as it is the method that allows sending data to the server and creating or updating a resource. In this case, the data would be the process parameters and the resource would be the process instance. The other options are not suitable for this purpose, as they either do not allow sending data or do not create or update a resource. References:

• HTTP Request Methods
• Start Process Web API

 The question is about AMUs (Appian Memory Units), which is a metric that measures the memory usage of a process model. The following statement is correct regarding this metric:

• Memory usage is considered low when it is below 100,000 AMUs. This is based on the Appian recommendation that each process model should use less than 100,000 AMUs on average, as higher memory usage can affect the performance or stability of Appian.

The following statements are not correct regarding this metric:

• Memory usage is considered low when it is below 10,000 AMUs. This is too low, as most process models will use more than 10,000 AMUs on average, depending on their complexity and data size.
• Memory usage is considered low when it is below 1,000 AMUs. This is too low, as even simple process models will use more than 1,000 AMUs on average, depending on their configuration and parameters.
• AMUs is not a good measurement for process memory usage. This is not true, as AMUs is a standardized and consistent measurement that reflects the relative memory usage of different process models in Appian.

References:

• AMUs (Appian Memory Units)

 Two things that can be done to increase the performance of a poorly-performing process model that has a lot of nodes and is mainly used to do background updates are:

• Remove all activity chaining. Activity chaining is a feature that allows a process to move from one node to another without waiting for a commit point. This can improve the performance of some processes, but it can also cause memory issues and data inconsistency if used excessively or incorrectly. Removing activity chaining can reduce the memory consumption and ensure data integrity of the process model.
• Refactor some nodes into subprocesses when possible. Subprocesses are processes that are called from within another process model. Refactoring some nodes into subprocesses can simplify the main process model and improve its readability and maintainability. It can also reduce the memory usage and execution time of the main process model, as subprocesses are executed in parallel and have their own memory allocation. References: Activity Chaining, Subprocess Node, Process Model Best Practices

The question is about the potential causes of a low completion rate of 10% for a process model. The following are two possible causes of this:

• The process instances are long-lived compared to the configured days until archival or deletion. This means that the process instances take a long time to complete, and they are archived or deleted before they reach the end event. This reduces the completion rate, as only the instances that reach the end event are counted as completed.
• A large number of instances are encountering process errors, and they are not being addressed by the production support team. This means that the process instances are stuck in an error state, and they cannot proceed to the next step or the end event. This reduces the completion rate, as only the instances that reach the end event are counted as completed.

The following are not likely causes of a low completion rate:

• A large value is configured for days until archival or deletion compared to other process models in your application. This means that the process instances have more time to complete before they are archived or deleted. This should increase the completion rate, as more instances can reach the end event before they are removed from the system.
• A large number of smart service nodes are configured in the process model. This means that the process model has a complex logic or functionality that requires multiple smart services. This does not directly affect the completion rate, as long as the smart services execute successfully and do not cause errors or delays.

References:

• Process Model Metrics
• Archiving and Deleting Process Instances

 The metric from the data_store_details.csv file that will help you understand the number of operations against data store is Total Count. This metric represents the total number of queries, inserts, updates, deletes, and executes performed against the data store during the specified time period. You can use this metric to identify which data stores are heavily used and may need performance tuning or scaling. References: [Data Store Details Report], [Data Store Metrics]

 The load time of this interface component can be improved by reducing the number of queries performed and the amount of data transferred. One way to achieve this is to prefetch the transaction types and use the displayvalue() function to display the Transaction Type for each transaction. This way, only one query is performed to get the transactions, and the transaction types are retrieved from a local variable instead of a separate query. This reduces the network latency and the database load, which can improve the performance of the interface. Therefore, the best answer is D.

References:

• Prefetching Data
• displayvalue() Function

Activity chaining is a feature that allows users to complete multiple tasks in a row without returning to their task list. However, activity chaining can also have some drawbacks, such as increased memory consumption, longer transaction times, and reduced user feedback. Therefore, some actions can be taken to make the process model more efficient, such as:

• Shorten long process chains by combining transactions into the smallest number of nodes. This can reduce the memory footprint and the database load of the process model.
• Avoid chaining system nodes like Integrations. These nodes can have unpredictable execution times and can cause timeouts or errors if chained. It is better to use asynchronous integrations or message events to decouple the process flow from external systems.
• Move transactions that can be done asynchronously outside of the chain. This can improve the responsiveness of the process model and allow parallel processing of independent tasks.

Therefore, the correct answers are B, C, and D.

References:

• Activity Chaining
• Performance Best Practices

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 xsd:key element is not supported within an Appian CDT. This element is used to define a key constraint for an element or a group of elements. Appian does not support key constraints in CDTs, as they are not relevant for data storage or manipulation. Instead, Appian uses primary keys and foreign keys to enforce uniqueness and referential integrity in CDTs. These keys are specified using the @Id and @JoinColumn JPA annotations, respectively. References: Supported XSD Elements and JPA Annotations

The two statements about the a!queryEntity() function that are true are:

• The entity value must be given as a constant of type Data Store Entity. This is because the entity value specifies which data store entity (table or view) to query from. The value must be a constant that references an existing data store entity in Appian Designer. You cannot use a variable or an expression for this value.
• Setting the fetchTotalCount parameter to False can improve the performance of the rule. This is because setting this parameter to False tells Appian not to calculate the total number of records that match the query criteria, which can be an expensive operation for large data sets. By default, this parameter is set to True, which means Appian will return the total count along with the query results. References: a!queryEntity() Function

 The type of plug-in that should be created to perform a job in the background and not be available under an expression rule, connected system, or the process model is a servlet plug-in. A servlet plug-in is a plug-in that allows you to create custom servlets that can be accessed through a URL. Servlets are Java classes that run on a web server and handle requests and responses. Servlet plug-ins can be used to perform background tasks, such as sending notifications, logging events, or integrating with external systems, without exposing them to the end users or developers. References: Servlet Plug-ins, Appian Suite Plug-ins