Appian ACD200 Appian Certified Senior Developer Exam Practice Test

 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 presenting data through data visualization and matching the chart types to the data they are best suited to represent. The following are the correct matches:

• A pie chart is best suited to represent proportional data in one category and can help us understand the contribution of parts to a whole. A pie chart shows the relative size of each part as a slice of a circular pie, and can display percentages or absolute values. For example, a pie chart can show the market share of different smartphone brands in one country.
• A line chart is best suited to represent direct comparison of data with multiple categories with a relatively small set of positive and negative values. A line chart shows the change or trend of data over time or another variable, and can display multiple lines for different categories. For example, a line chart can show the temperature change of different cities over a year.
• A bar chart is best suited to represent values across a relatively large number of categories that are not sequential or time-based. A bar chart shows the magnitude or frequency of data using horizontal or vertical bars, and can display multiple bars for different categories. For example, a bar chart can show the number of students enrolled in different courses in a university.

References:

• Pie Chart
• Line Chart
• Bar Chart

 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

Two valid suggestions regarding this process are:

• We should consider adding a timer exception which skips the “Edit/Credit Invoice” node after 24 hours. This suggestion would improve the user experience by preventing users from editing or crediting an invoice that is too old or has been already processed by another system. A timer exception can be added to any activity node to specify a deadline for completing the task. If the deadline is reached, the process flow will follow the exception path instead of the normal path.
• We should add this process model as a related action on the Invoices record called “Edit Invoice.” This suggestion would make it easier for users to access and execute this process from the context of a specific invoice record. A related action is a process model that can be initiated from a record or a record list in Tempo or sites. A related action can use record data as inputs and update record data as outputs. References: Timer Exception, Create Record Actions

References:

• [Web APIs]
• [Connected Systems]
• [Expression Rules]
• [Decision Tables]

The @Version annotation is used to avoid the collision of data from an application when more than one user is editing the same record in a database. The @Version annotation enables optimistic locking, which is a mechanism to detect and prevent concurrent updates on the same record. Optimistic locking assumes that multiple transactions can complete without affecting each other, and that therefore transactions do not need to lock data resources until they are ready to commit. However, if a transaction tries to commit changes to a record that has been modified by another transaction since it was last read, an OptimisticLockException is thrown and the transaction is rolled back. The @Version annotation can be applied to a field or property of a CDT that stores a numeric value. This value is used as a version number that is automatically incremented by Appian every time the record is updated. References: Does Appian support @Version JPA Annotation?, JPA - Optimistic Locking and Use of @Version annotation

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

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

 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 most efficient way to achieve the integration between the third-party document scanner and the Appian record list is to create a view between both the [appian].[document] and [appian].[caseData] tables to feed the record. A view is a virtual table that is defined by a query and does not store any data. It can join, filter, aggregate, or transform data from one or more tables and present it in a desired format. A view can be used to simplify complex queries, provide security, or enhance performance. By creating a view, the record can show data from both tables without duplicating or copying any data. Therefore, the correct answer is C.

References:

• Relational Database Guidance
• Views

 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

 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.

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]

An index is a data structure that allows for faster retrieval of data from a table based on one or more columns. Indexes increase the performance of read operations, such as select queries, by reducing the number of records that need to be scanned. However, indexes decrease the performance of write operations, such as insert, update, and delete queries, by requiring additional work to maintain the index structure and ensure its consistency with the table data. Therefore, indexes should be used judiciously and only on columns that are frequently used in queries and have high selectivity (i.e., low number of duplicate values). 

An integration that modifies data can be called from three locations: web API (POST, PUT, DELETE), process model, and SAIL saveInto parameter. These locations allow for sending data to an external system or service and receiving a response.

• Web API (POST, PUT, DELETE) are HTTP methods that are typically used to create, update, or delete data on a server. An integration that modifies data can be exposed as a web API with one of these methods, allowing external applications or systems to invoke it through an HTTP request1.
• Process model is a graphical representation of a business workflow that consists of nodes and flows. An integration that modifies data can be called from a process model using either an integration node or a Call Integration smart service2. This allows for orchestrating complex workflows that involve data manipulation across different systems or sources.
• SAIL saveInto parameter is a property of a SAIL component that specifies an expression to be evaluated when the component is modified by the user3. An integration that modifies data can be called from an interface using the saveInto parameter of a SAIL component. This allows for triggering data changes based on user actions or events on the interface.

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 performance log that should be used to see the mean evaluation time of a slow-performing expression rule every hour is expressions_details.csv. This log records information about how expression rules are performing in the system, such as the number of evaluations, the total time, the mean total time, and the standard deviation of the total time. The log is written to once every hour, and it provides fine-grain aggregation by type of expression rule. The mean total time column shows the average time it took to evaluate an expression rule in milliseconds. Therefore, the correct answer is A.

References:

• Expression Performance Logs
• 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 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 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

 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