ACD200 Exam Dumps - Appian Senior Developer Questions and Answers

The three actions that can be taken to minimize the performance impact of the Tempo report are:

• Limit the number of series values and categories in the report. This is because having too many series values and categories can make the report difficult to read and render, as well as increase the amount of data that needs to be transferred from the database to Appian. A good practice is to limit the number of series values to 10 or less, and the number of categories to 20 or less.
• Use local variables in your report interface to avoid redundant database queries. This is because local variables can store the results of database queries and reuse them in multiple places within the interface, reducing the number of times the database is accessed. A good practice is to use local variables for common filters, aggregations, or calculations that are used in multiple charts or grids.
• Perform aggregation in the database using a view prior to reading the data into Appian. This is because performing aggregation in the database can reduce the amount of data that needs to be transferred from the database to Appian, as well as leverage the database’s optimization capabilities. A good practice is to create a view in the database that performs the aggregation and then query that view using Appian. References: Report Performance Best Practices

 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 requirement is to create a service account for a consumer to access the Appian Web API. A basic user is the user type that should be created for this purpose, as it has the minimum permissions needed to invoke web APIs and does not consume a license. A basic user can also be assigned to specific groups or roles to control the access to web APIs. The other options are not suitable for this purpose, as they either have more permissions than needed or consume a license. References:

• User Types
• Web API Security

The most efficient method to insert the deleted row of a table into a history table for audit purposes is Trigger. This is because a trigger is a database object that automatically executes a specified SQL statement when a certain event occurs on a table or view. A trigger can be defined to run before or after a delete operation on a table, and can access the deleted row using a special table called deleted. A trigger can perform the insertion of the deleted row into the history table without any additional logic or overhead from Appian. References: Triggers

 The question is about the default limit for maximum number of node executions in a repeating step in a process. The default limit is 1000, as it is the value of the system property conf.bpm.maxNodeExecutionsPerInstance, which controls how many times a node can be executed in a single process instance. This limit is intended to prevent infinite loops or excessive node executions that could affect the performance or stability of Appian. The other options are not correct, as they are either too high or too low. References:

• Repeating Steps in Processes
• System Properties Reference

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

 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

When building a process model that transforms a large data set, two things that should be ensured to include in the process model are an XOR gateway before the transformation node, to check for empty/null values, and a transformation applied with an expression rule that takes the data set as an input, and loops through the dataset using a looping function, such as foreach. These things can help to improve the performance and reliability of the process model. The XOR gateway can prevent unnecessary processing of empty or null data sets, which can save time and resources. The expression rule can perform the transformation in one transaction, instead of using multiple nodes or subprocesses, which can reduce the memory footprint and the database load of the process model. Therefore, the correct answers are B and D.

References:

• [XOR Gateway]
• [Expression Rules]
• [foreach() Function]

The most likely root cause of the error is that the view contains a large number of rows, requiring more time to fetch the data. This can result in a timeout or an out-of-memory error. To avoid this, you can use pagination or filters to limit the number of rows returned by the view. You can also optimize the view performance by using indexes, avoiding unnecessary joins, and reducing the number of columns. References: [Views], [View Performance]