Appian ACD200 Appian Certified Senior Developer Exam Practice Test

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

 A sprint retrospective is a meeting that takes place at the end of each sprint, where the team reflects on what went well and what can be improved in their work process. The purpose of the retrospective is to identify and implement actions that can enhance the team’s performance and satisfaction in future sprints. Two basic questions that can help facilitate the retrospective are: What went well? and What didn’t go well and can be improved? These questions allow the team to celebrate their achievements, acknowledge their challenges, and generate ideas for improvement.

The correct representation of Appian best practices for using pie charts is to use pie charts to show proportional data. Pie charts are generally used to show how individual parts contribute to a whole, such as percentages or fractions. Pie charts should only be used to represent data that can be placed into distinct categories and should not consist of more than 6 slices. Pie charts should also include value and category labels for each slice, and sort the data values in ascending or descending order. References: Pie Chart Component, Charts UX Design Guide

 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]

 A many-to-many relationship is a type of relationship where multiple records in one table are associated with multiple records in another table. To implement a many-to-many relationship, a third table is needed to store the associations between the two entities. In this case, the third table would store the employee ID and the skill ID for each pair of employee and skill. This design allows for efficient querying and updating of the data, as well as avoiding data redundancy and inconsistency. 

 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 practices are strongly discouraged for activity chaining, such as having more than 50 node instances or more than 5 seconds between attended activities. These practices can cause performance issues, user frustration, or process failures. Therefore, the correct answers are B and C.

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

 A materialized view is the best option to show joined data from 5 tables that contain a large number of rows and could generate a large result set after executing the joins. A materialized view is a physical table that holds the results of the SQL that a view would normally be constructed from and can be generated periodically. A materialized view can improve performance by reducing the execution time of complex queries that involve multiple joins, aggregations, or calculations. A materialized view can also reduce the load on the database server by storing the query results in advance. A materialized view can be refreshed at regular intervals or on demand to reflect the changes in the underlying tables. References: [Materialized Views], [View Performance]

The question is about a sign that an application’s performance is degrading and should be addressed with changes to the application design. The following is a sign of this:

• Three of the top five most executed process models have a low completion percentage. This means that a large proportion of the process instances are not reaching the end event, either because they are taking too long to complete, or because they are encountering errors or exceptions. This can affect the performance of the application, as it can consume more memory and resources, and reduce the availability and reliability of the application. You should review the process model design and identify the causes of the low completion rate, and make changes to improve the process efficiency and error handling.

The following are not signs of performance degradation that require changes to the application design:

• Integration calls to an external system are consistently returning an HTTP status code of 500. This means that the external system is experiencing an internal server error, which is not related to the application design. You should contact the external system provider and report the issue, or implement a fallback or retry mechanism in your integration logic.
• The number of tasks assigned to users has increased from 1 per day to 5 per day. This means that the workload or demand for the application has increased, which is not necessarily a sign of performance degradation. You should monitor the task completion rate and user feedback to see if the increase in tasks is affecting the user experience or satisfaction, and adjust the task assignment or prioritization logic if needed.
• The number of objects in the Application has increased from about 100 to about 500. This means that the application has grown in size and complexity, which is not necessarily a sign of performance degradation. You should follow the best practices for application design and maintenance, such as using folders, prefixes, dependencies, and documentation, to keep the application organized and manageable.

References:

• Process Model Metrics
• HTTP Status Codes
• Task Report
• Application Design

According to Appian best practices, environment-specific constants should be used to define values that vary from one Appian environment to another. For example, if you want to generate an email body that contains the environment name, you can create a constant named ENVIRONMENT_NAME and assign it different values for DEV and TEST environments. This way, you can avoid hard-coding values in your expressions or rules, and simplify your deployment process by using automatic constant value mapping.

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

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 lowest permission required on the data store in order to query, write, and delete data is Viewer. This is because the data store permissions only control the ability to view and modify the data store object in Appian Designer, not the actual data in the database. To query, write, and delete data, the user needs to have the appropriate SQL permissions on the database tables or views that are mapped to the data store entities. References: Data Store Permissions

The likely cause for a task on a newly-launched process in Production being slow to respond to user input is having too many SAIL components on the task. SAIL components are the UI elements that make up an interface in Appian. Having too many SAIL components on a task can negatively impact the performance and user experience of the interface, as it increases the rendering time and complexity of the interface. It can also cause browser compatibility issues or memory leaks. It is recommended to limit the number of SAIL components on a task to less than 100, and to use grids, collapsible layouts, or tabs to organize and display data efficiently. References: SAIL Components Overview, SAIL Performance Tips

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 best way to restrict the uploading of documents without extensions at the environment level is to enable the File Upload > Block files without an extension option under the Administration Console. This option will prevent users from uploading files that do not have a valid file extension, such as .docx, .pdf, or .png. This can help to avoid security risks and compatibility issues with unsupported file types. Therefore, the correct answer is A.

References:

• [File Upload Settings]
• [File Extensions]

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]

The first place to go to find more details on why the Send E-Mail node encountered an error is to investigate the application server stdout log. This log contains information about the email server configuration, connection status, and error messages. You can access this log from the Administration Console under Monitoring > Logs > Application Server Logs > stdout.log. You can also search for keywords like “email” or “smtp” to filter the relevant entries. References: [Send E-Mail Smart Service], [Application Server Logs]

 Object security settings can be changed in bulk in the application security summary and the compare and deploy tool. The application security summary provides a centralized view of the security role maps for all objects in an application. You can filter, sort, and edit the role maps from this view. The compare and deploy tool allows you to compare objects between two environments and deploy changes from one environment to another. You can also edit the role maps of the objects before deploying them. References: Application Security Summary, Compare and Deploy Tool

 Peer Dev Review is the most efficient way to coach team members and improve code quality, because it allows developers to share feedback, learn from each other, and identify and fix issues before they become problems. Peer Dev Review also fosters collaboration, communication, and best practices among the team. Peer Dev Review can be done using tools like Appian Designer or Appian Code Review. References: [Peer Dev Review], [Appian Code Review]

The question is about allowing external systems to invoke Appian web APIs. A service account is the user role that should be used for this purpose, as it is a special type of basic user that can be configured to authenticate with web APIs using an API key. A service account can also be assigned to specific groups or roles to control the access to web APIs. The other options are not user roles, but rather groups or user types that are not suitable for this purpose. References:

• Service Accounts
• Web API Security

 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