Free ACD200 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

A Connected System is the Appian design object specifically created to store and manage connection information for an external system. It centralizes the base URL, authentication method, and credentials. This allows multiple integration objects, which define the specific operations or endpoints, to reference the same Connected System. By doing so, developers can reuse the connection and authentication details without duplicating them, which simplifies maintenance and enhances security. If credentials or the base URL change, they only need to be updated in the single Connected System object.

1. Appian Documentation

"Connected System Object": The introduction states

"Connected system objects represent an external system and contain all the information necessary to connect to that system... This allows you to create multiple integrations that all use the same connected system."

2. Appian Documentation

"Integration Object": In the "Configuration" section

it details that an integration must be configured with a connected system. It states

"The connection details

such as the server and authentication

are configured in the connected system." This confirms that the integration object consumes details from the connected system.

3. Appian Documentation

"Creating Integrations": This guide outlines the standard development pattern: "Before you create an integration

you'll need to create a connected system to store the base URL and authentication details for the external system you want to connect to." This explicitly defines the Connected System's role as the prerequisite for sharing connection details.

A database trigger is the most efficient design as it operates directly at the data source level, independent of the Appian execution engines. When a record is modified via any Appian action, the database trigger automatically captures the changes and writes them to an audit table within the same database transaction. This approach completely offloads the auditing logic from the Appian application, resulting in the lowest possible performance impact on Appian's servers. The auditing process is transparent to the Appian objects (e.g., process models, interfaces) that perform the data modification, ensuring minimal overhead and complexity within the application itself.

1. Appian Corporation. (2023). Data-Centric Design. Appian Documentation. In the "Leverage the Database" section

the documentation advises

"Leverage the database for what it does best: managing and manipulating large sets of data... For example

if you need to update thousands of rows in a database table

it is much more efficient to call a stored procedure from Appian than it is to loop through those updates in a process model." This principle directly supports offloading the row-level audit task to a database trigger for maximum efficiency.

2. Appian Corporation. (2023). Record Events. Appian Documentation. This document describes the Appian-native approach of using record events to trigger a process. While a valid pattern

this method still consumes Appian application resources to handle the event and execute a process

making it less efficient and having a greater impact than a database trigger that operates outside the Appian execution engine.

3. Silberschatz

A.

Korth

H. F.

& Sudarshan

S. (2019). Database System Concepts (7th ed.). McGraw-Hill. Chapter 8

"Advanced SQL

" discusses the use of triggers for maintaining data integrity and creating audit trails. The text explains that triggers are executed by the database system automatically as a part of the modifying transaction

which is inherently more efficient for auditing than an external application-layer process.

In the Scrum framework, the Product Owner is the sole individual accountable for managing and prioritizing the Product Backlog. This responsibility is central to the role and ensures a single, clear source of direction for the product's development. The Product Owner orders the backlog items to best achieve the product goals and maximize the value delivered by the Scrum Team. While the Product Owner may take input from stakeholders, the Development Team, and the Scrum Master, the final authority on the order of the backlog rests exclusively with them.

1. Schwaber

K.

& Sutherland

J. (2020). The Scrum Guide. Scrum.org. p. 5. The guide states

"The Product Owner is also accountable for effective Product Backlog management

which includes: ... Ordering Product Backlog items".

2. Appian Corporation. (n.d.). Appian Delivery Methodology. Appian Academy Online. In the "Project Roles and Responsibilities" section

the Product Owner is defined as the role responsible for defining and prioritizing user stories

which constitute the product backlog.

3. Rubin

K. S. (2012). Essential Scrum: A Practical Guide to the Most Popular Agile Process. Addison-Wesley Professional. Chapter 5

"The Product Owner Role

" details that a primary responsibility of the Product Owner is to be the "single-willed owner of the product backlog" and to manage its contents and ordering.

4. Pichler

R. (2010). Agile Product Management with Scrum: Creating Products that Customers Love. Addison-Wesley Professional. Chapter 2

"The Product Owner Role

" emphasizes that the Product Owner is responsible for the product backlog and for prioritizing it to maximize business value.

To execute an Appian Web API, the calling user or service account must have a minimum of Viewer permissions to the Web API object. This aligns with the principle of least privilege, granting only the necessary rights to invoke the endpoint without allowing modification. Higher permission levels, such as Editor or Administrator, also permit execution but provide additional capabilities (e.g., editing the object's definition, managing security) that are not required for an end user to simply call the API. Therefore, Viewer is the correct minimum privilege level.

1. Appian Corporation. (2023). Web API Object. Appian 23.4 Documentation. In the "Security" section

it states: "Users must have at least Viewer permissions to the web API to execute it."

2. Appian Corporation. (2023). Object Security. Appian 23.4 Documentation. This document outlines the standard permission levels (Administrator

Editor

Viewer

Deny) and their general functions

reinforcing that Viewer permissions are intended for users who need to see or use an object at runtime without modifying it.

The sprint retrospective is a key ceremony within the Appian Delivery Methodology, which is founded on Agile and Scrum principles. The primary goal of this meeting is to inspect the previous sprint and create a plan for improvements in the next one. The two most fundamental questions that structure this discussion are "What went well?" and "What didn’t go well?". These questions encourage the team to reflect on both successes to be continued and challenges to be addressed, fostering a culture of continuous improvement focused on the team's processes, interactions, and tools.

B. What are the blockers?

This question is primarily addressed during daily stand-up meetings to ensure impediments are removed quickly, rather than waiting for the end-of-sprint retrospective.

C. Who did well in this sprint?

The retrospective focuses on the team's process and collaboration, not on singling out individual performance, which can hinder open and honest feedback.

1. Appian Community

Appian Delivery Methodology

"Execute Sprints": The official documentation describes the Sprint Retrospective's purpose: "The purpose of the Sprint Retrospective is to plan ways to increase quality and effectiveness. The Scrum Team inspects how the last Sprint went with regards to individuals

interactions

processes

tools

and their Definition of Done." This inspection is facilitated by asking what went well and what could be improved.

2. The Scrum Guide (scrumguides.org)

November 2020

"Sprint Retrospective

" p. 11: While not Appian-specific

Appian's methodology is based on Scrum. The guide states the purpose is to "plan ways to increase quality and effectiveness." It suggests topics for inspection include "individuals

interactions

processes

tools

and their Definition of Done

" which are naturally explored by asking what went well and what didn't.

An integration designed to modify data can be invoked from several locations within an Appian application. It can be called asynchronously within a process model using the dedicated "Call Integration" smart service. It can also be called synchronously from any expression using the a!integration() function. This allows it to be used directly in an expression rule or, very commonly, within the saveInto parameter of a SAIL interface component to trigger the data modification in response to user interaction.

A. Web API (GET): A Web API is an endpoint that exposes Appian functionality to external systems; it is not a location within Appian from which you call an integration.

C. Web API (POST, PUT, DELETE): Similar to the GET Web API, this object is an inbound endpoint. While it can execute an integration internally, it is not a location where a designer calls the integration from.

1. Process Model (D): "The Call Integration smart service is a powerful tool that allows you to start an integration from a process model."

Source: Appian Documentation

"Call Integration Smart Service".

2. Expression or Rule (B) & SAIL saveInto parameter (E): "You can call an integration from any expression using the a!integration() function. This allows you to call an integration from an interface

web API

or other expression." The documentation further clarifies its use in interfaces: "For example

you could use this function in the saveInto parameter of a button component..."

Source: Appian Documentation

"Calling an Integration".

3. SAIL saveInto parameter (E): The a!save function

used within saveInto

can execute an integration rule. "The value parameter [of a!save] is...evaluated and saved into the target...when the user interacts with the component." This evaluated value can be the result of an a!integration() call.

Source: Appian Documentation

"a!save() Function".

The process model completion rate is the percentage of instances that have successfully finished. A low rate of 10% indicates that 90% of instances are not completing.

Option A is correct because if a process is designed to be long-running but the archival policy is set to a shorter duration, instances will be archived before they can finish. Archived processes are not considered "completed," thus directly lowering the completion rate.

Option B is correct because instances that encounter an error are paused and enter an exception state. These paused instances are not "completed." If a large number of these errors are not resolved, they will accumulate, significantly reducing the overall completion rate.

C. A large value for archival days gives processes more time to complete, which would likely increase, not decrease, the completion rate.

D. The number of nodes does not directly determine the completion rate; a complex process can still have a 100% completion rate if designed correctly.

1. Appian Documentation

Process Model Metrics: The "Completion" metric is defined as the percentage of process instances that completed. Instances that are active

paused by exception

or canceled are considered "Not Completed." This supports the reasoning that paused (errored) processes (Option B) lower the completion rate.

Source: Appian 23.4 Documentation

"Process Model Metrics" section.

2. Appian Documentation

Archiving Processes: "Archived or deleted processes are not included in process reports..." and "If a process is archived before it is completed

it will never be completed." This directly supports the reasoning that premature archival due to a short archival period for long-lived processes (Option A) causes a low completion rate.

Source: Appian 23.4 Documentation

"Data Management" page

"Archiving Processes" section.

The most efficient and standard Appian design pattern for this requirement is to use a database view. A view creates a virtual table by joining the [appian].[document] and [appian].[caseData] tables. Appian can then use this single view as the data source for the record type. This approach avoids data duplication, ensures data is always current, and centralizes the join logic within the database, which is optimized for such operations. This allows Appian's query engine to efficiently filter, sort, and page the combined data for the record list.

A. Creating a trigger to copy data results in data duplication. This is inefficient, increases storage requirements, and introduces potential data integrity and maintenance complexities.

B. An SSIS package is a batch process that runs on a schedule. This would introduce data latency, meaning the record list would not display real-time information.

D. An Appian record type cannot directly use a stored procedure as its queryable data source. Record types require a table or view that Appian can dynamically query for filtering, sorting, and paging.

1. Appian Documentation

Record Type Object: "The source of a record type can be a process model

a database table or view

or a Salesforce object." This confirms that a view is a valid and intended data source.

Source: Appian 23.4 Documentation

"Objects" -> "Record Type Object".

2. Appian Documentation

Database Schema Best Practices: "Use views to pre-join or de-normalize data. If you have a normalized schema

create views to de-normalize the data for use in Appian... This is the most common and recommended way to create a read-only data source for records and read-only grids."

Source: Appian 23.4 Documentation

"Data" -> "Database Schema Best Practices" -> "Denormalization".

When selecting a plug-in from multiple similar options, the primary goal is to ensure it is functional, deployable in the target environment, and capable of meeting the specific requirement.

1. Compatibility (A): The plug-in must be compatible with the Appian version of the target environment to function correctly and avoid system instability.

2. Cloud Approval (B): For Appian Cloud environments, only Cloud-approved plug-ins can be deployed, making this a critical go/no-go criterion.

3. Limitations (C): Understanding a plug-in's limitations is essential to verify that it can fully satisfy the business requirement without introducing unacceptable constraints.

D. What is the size of the plug-in?

Plug-in size is a minor technical detail and rarely a primary factor in selection, as its impact on system performance or storage is typically negligible compared to functionality and compatibility.

E. Who is the plug-in author?

While the author can indicate the level of support and reliability, it is a secondary consideration to the plug-in's fundamental compatibility, deployability, and ability to meet functional requirements.

1. Appian Documentation

Appian AppMarket: When viewing a plug-in on the AppMarket

the "Overview" tab prominently displays key evaluation criteria. This includes the Appian Version compatibility and whether the plug-in is Cloud-approved. The page also provides a link to the plug-in's own documentation

which is the source for understanding its features and limitations. This directly supports options A

B

and C.

Source: Appian 23.4 Documentation

"Appian AppMarket".

2. Appian Documentation

Deploying Plug-ins to the Cloud: This section explicitly states

"Only Appian-approved plug-ins from the AppMarket can be deployed to Appian Cloud sites." This highlights the critical importance of checking the Cloud-approved status (Option B) for any cloud-based development.

Source: Appian 23.4 Documentation

System Administration > Administration Console > PLUG-INS

"Deploying Plug-ins to the Cloud" section.

3. Appian Documentation

Managing Plug-ins: The documentation on managing plug-ins emphasizes the need to ensure compatibility. It notes that plug-ins are specific to Appian versions and that an incompatible plug-in can cause errors or fail to deploy

reinforcing the primacy of checking version compatibility (Option A).

Source: Appian 23.4 Documentation

System Administration > Administration Console > PLUG-INS

"Managing Plug-ins" section.

To optimize the performance of a Tempo report querying an external database, a multi-layered approach is necessary. First, performing data aggregation in the database using a view (E) is crucial. This leverages the database's processing power, reducing the volume of data transferred to and processed by Appian. Second, within the report's interface, using local variables (C) to cache the queried data prevents redundant database calls, especially in interactive reports with filters. Finally, limiting the number of series and categories displayed in charts (B) minimizes the amount of data the browser must render, directly improving the end-user's experience and interface responsiveness.

A. Displaying the report as a task report is incorrect because task reports are specifically designed to display data about Appian process tasks, not general data from an external business database.

D. The queryprocessanalytics() function is used to query Appian's internal process analytics engine. It cannot be used to retrieve data from an external business database as required by the scenario.

1. For option E: Appian Documentation

"Querying Data from an RDBMS". This guide emphasizes offloading work to the database. It states

"When possible

use a database view to pre-join or filter data... Let the database do what it is good at: sorting and aggregating." This directly supports performing aggregation in the database.

2. For option C: Appian Documentation

"Local Variables". The documentation explains that local variables "can be used to store data that is used multiple times in an interface

" which prevents the re-evaluation of expressions

including database queries

thus improving performance. See the section on "Caching Data."

3. For option B: Appian Documentation

"Chart Configuration Best Practices". This page advises on performance

stating

"Limit the number of data points... Displaying too many data points on a chart can negatively impact its performance and readability." This directly supports limiting series and categories.

4. For options A & D: Appian Documentation

"Reports". This section clarifies the different types of reports and their data sources. It distinguishes between reports on process data (using process analytics) and reports on business data from external sources

confirming that task reports and queryprocessanalytics are inappropriate for this use case.

A database trigger is the most efficient method for this requirement. A trigger is a specialized stored procedure that executes automatically in response to a specific data modification event (e.g., DELETE) on a table. By using an AFTER DELETE trigger, the deleted row's data can be captured and inserted into a history table within the same database transaction. This approach is highly efficient as it occurs at the database level, minimizing network latency and application server overhead, and ensuring the audit action is atomic with the deletion.

A. Materialized view: A materialized view is a physical copy of query results used for performance, not an event-driven mechanism to capture real-time row deletions for auditing.

B. Process model: Using an Appian process model would involve reading the data, writing it to the history table, and then deleting it. This adds significant application-level overhead and is less performant than a native database trigger.

C. View: A standard view is a virtual table based on a query. It does not store data and cannot be used to capture a row after it has been deleted from the base table.

1. Appian Documentation - Database Performance Best Practices: While not explicitly naming triggers

the documentation emphasizes the principle of efficiency. It states

"When possible

perform data-intensive operations in the database rather than in process memory." A trigger perfectly aligns with this principle by handling the audit logging directly within the database

which is more efficient than pulling data into an Appian process model to perform the same logic. (See the section on "Use the Database to Handle Large Data Sets").

2. Appian Documentation - Write to Data Store Entity Smart Service: This documentation outlines the Appian-based method for deleting data. To achieve the audit requirement using this

a developer would need to chain multiple smart services (e.g.

query

write to history

delete from primary). This multi-step

application-layer process is inherently less efficient than a single

atomic database-level trigger.

3. Silberschatz

A.

Korth

H. F.

& Sudarshan

S. (2020). Database System Concepts (7th ed.). McGraw-Hill. Chapter 9

"Triggers

" explains that a primary use case for triggers is to maintain audit trails and log records. It states

"Triggers can be used to log modifications to a relation. The log can be stored in a separate relation... When a tuple is deleted

a trigger can insert a copy of the tuple into the log relation." This foundational database text confirms that triggers are the standard

intended mechanism for this task.