ACD200 Appian Certified Senior Developer Free Practice Exam Questions (2025 Updated)

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

 According to Appian best practices, the preferred style and size for the images to display the profile picture of each employee inside an employee grid are style: “AVATAR” and size: “SMALL”. This is because the avatar style creates a circular image that is suitable for profile pictures, and the small size creates a 32x32 pixel image that fits well inside a grid cell. The standard style creates a rectangular image that may not look good for profile pictures, and the large size creates a 128x128 pixel image that may be too big for a grid cell. References: Image Component

The instances of the process model that will be affected by modifying the automatic process clean-up settings are future and past instances of the process model. The automatic process clean-up settings allow you to specify how long completed or canceled processes should be kept before being archived or deleted. These settings apply to all instances of the process model, regardless of when they were started or completed. However, these settings do not affect any subprocesses that are part of the process model. Subprocesses have their own archival settings that can be configured separately. References: Automatic Process Clean-up Settings, Archiving Processes

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 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 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

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.

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.

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). 

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

 Two true statements are:

It is not possible to undo changes from an import to all types of objects. Once a package is imported to an environment, it applies changes to the existing objects or creates new objects based on the package contents. There is no built-in mechanism to revert these changes or delete these objects automatically. Therefore, it is important to test the package in a non-production environment before importing it to production, and to backup any objects that may be overwritten by the import.

It is possible to import the same package multiple times. A package can be imported to an environment more than once, as long as it does not contain any conflicts or errors that would prevent the import. However, importing the same package multiple times may not have any effect if there are no changes in the package contents or in the target environment since the last import. References: Prepare Deployment Packages, Application Deployment Guidelines

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

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

 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

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()

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

 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 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

 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