ACD301 Practice Questions

The key symptoms described—a high Work Queue - Java Work Queue Size and slow execution of unattended process activities—are direct indicators of an overloaded process execution engine tier. The Java work queue represents tasks waiting for an engine thread to become available. A persistently high value means the rate of incoming work exceeds the system's processing capacity. Adding more engine replicas is the standard Appian scaling strategy to increase parallel processing throughput for background activities, thereby distributing the load and reducing the queue size and execution times.

B. Optimize slow-performing user interfaces.

This addresses front-end performance. The core issue identified is with back-end, unattended processing, not user-facing interface rendering.

C. Add more application servers.

This scales the web tier to handle more concurrent user sessions and HTTP requests, which is not the bottleneck indicated by the engine work queue.

D. Add execution and analytics shards.

Sharding is a data partitioning strategy for managing extremely large data volumes, not for resolving processing throughput bottlenecks under normal sustained load.

---

1. Appian Documentation

System Administration Section

Engine Performance Logs: The Work Queue - Java Work Queue Size metric is described as representing the number of tasks waiting for an engine thread. The documentation states

"A high value for this metric indicates that the engine is receiving more work than it can process in a timely manner." This directly supports the diagnosis of an engine bottleneck. (Found in Appian 23.4 Documentation under System Administration > Health Check > Log Analysis > Engine Performance Logs).

2. Appian Documentation

High Availability and Disaster Recovery Guide

Scaling Appian Section: This guide outlines the architecture and scaling strategies. It specifies that to increase processing capacity for process models

you should add replicas of the execution and analytics engines. This distributes the processing load across multiple servers

directly addressing the scenario's throughput problem. (Found in Appian 23.4 Documentation under System Administration > High Availability and Disaster Recovery > Scaling Appian).

The standard and most direct Appian method for connecting to an external relational database, such as Oracle, is to configure it as a data source in the Administration Console. This establishes the JDBC connection. Once the data source is configured, you can create a data store that points to it and define data store entities that map to the database tables or views. The a!queryEntity() function can then be used directly within an interface expression to query this data in real-time, providing an efficient and scalable solution for displaying external data to users.

A. The Query Database smart service in a process model is primarily for workflow automation, not for populating user interfaces. Using it for UI data retrieval introduces unnecessary latency and complexity.

B. This describes a data synchronization or caching pattern. It does not provide a real-time query of the third-party database and introduces data staleness, which may not meet user requirements.

C. This approach is incorrect because it suggests using an API to connect to a database. The standard and more direct method is a JDBC connection configured via a data source, not an expression-backed record calling a web API.

1. Appian Documentation

Data Sources: "To connect to an external database

you must first create a data source in the Admin Console. A data source contains the connection information for a database." This establishes the first step outlined in the correct answer. (Appian 23.4 Documentation

"Data Sources" section).

2. Appian Documentation

Data Stores: "A data store is a reference to an external relational database... Each data store contains a reference to a data source... Once you have a data store and at least one data store entity

you can use the Query entity smart service or the a!queryEntity() function to query your data." This confirms the second part of the correct answer's workflow. (Appian 23.4 Documentation

"Data Store" object page).

3. Appian Documentation

a!queryEntity(): "The a!queryEntity() function is used to query a data store entity and return the result." This function is the standard mechanism for retrieving data from a configured data store for use in expressions

such as those that define an interface. (Appian 23.4 Documentation

"Querying Data From a Data Store Entity" page).

To ensure the record grid performs efficiently, database indexes should be created on columns used for filtering and joining. The requirements state that users must filter by priority and status, making it essential to index these two columns. The record's data source is a view that joins the case and site tables on the siteid column. Indexing the foreign key column (siteid in the case table) is a critical best practice to accelerate the performance of this join operation. Therefore, siteid, status, and priority are the most important columns to index.

C. name: The requirements do not specify filtering or sorting by the site name, so an index on this column is not necessary.

D. modifieddate: This column is not used for filtering or sorting according to the scenario, making an index less critical for performance.

F. caseid: As a primary key, this column is automatically indexed by the database system, so it does not need to be explicitly chosen for indexing.

---

1. Appian Documentation

"Database Performance Best Practices."

In the "Use Indexes" section

the documentation states: "Add indexes for any columns that will be used for filtering

sorting

or joining. This includes foreign key columns

columns that will be used in query filters...". This directly supports indexing status and priority (for filtering) and siteid (for joining).

2. Appian Documentation

"Record Type Object."

In the section on data sources

it is explained that when using a database view

the performance of the record type is dependent on the performance of the underlying query. This reinforces the need to apply standard database optimization techniques

such as indexing

to the tables that constitute the view. The efficiency of the join and filters in the view's query is paramount.

A successful data volume testing strategy requires establishing realistic data targets and integrating testing into the development lifecycle. The volume of data for testing should be based on current and projected production usage, which must be defined by business stakeholders and project sponsors to ensure the tests are meaningful. Furthermore, incorporating performance testing with this data volume into the "Definition of Done" for each sprint ensures that performance issues are identified and addressed early and iteratively, preventing major problems late in the project.

A. Retaining data from previous tests creates an inconsistent baseline, making test results unreliable and non-repeatable. Test environments should be reset to a known state before each run.

B. Using Appian processes to load large datasets for test setup is highly inefficient. Direct database utilities are significantly faster and are the appropriate tools for pre-populating the environment.

E. Deferring data model changes until the end of the project is a major anti-pattern. It introduces significant risk and can lead to extensive, costly rework across the entire application.

1. Appian Corporation

"Performance Testing" Documentation.

Reference for C: In the "Prepare for the Test" section

under "Prepare the Test Environment

" the guide states: "Populate the environment with a representative dataset. Determine the expected volume of data in production after a period of time (for example

1-3 years)." This directly supports that data volume should be based on stakeholder-driven estimations of production usage.

Reference for D: The "Overview" section emphasizes an iterative approach: "Performance testing should be an iterative process that is conducted throughout the project lifecycle

not a one-time event at the end of a project." This aligns with making testing part of the sprint's "Definition of Done."

2. Pressman

R. S.

& Maxim

B. R. (2020). Software Engineering: A Practitioner's Approach (9th ed.). McGraw-Hill.

Reference for D: Chapter 5

"Agile Development

" discusses the "Definition of Done" (DoD). A comprehensive DoD typically includes quality assurance criteria such as the completion of performance and load testing for the features developed within the sprint

confirming that continuous testing is a core agile principle.

3. University of Washington

CSE 403: Software Engineering

"Testing I" Lecture Notes.

Reference for A & B: Course materials on software testing frequently emphasize the principles of test environment management

which include ensuring a clean

known state before test execution (contradicting A) and using the most efficient methods to establish that state (contradicting B). The goal is to test the application's performance

not the data loading mechanism itself

unless that is the specific test case.

Archive processes 2 days after completion or cancellation. → Processes that need to be available for

2 days after completion or cancellation, after which are no longer required nor accessible.

Use system default (currently: auto-archive processes 7 days after completion or cancellation). →

Processes that remain available for 7 days after completion or cancellation, after which remain

accessible.

Delete processes 2 days after completion or cancellation. → Processes that need to be available for 2

days after completion or cancellation, after which remain accessible.

Do not automatically clean-up processes. → Processes that need remain available without the need

to unarchive.

Comprehensive and Detailed In-Depth Explanation:

Appian provides process model data management strategies to manage the lifecycle of completed or

canceled processes, balancing storage efficiency and accessibility. These strategies—archiving, using

system defaults, deleting, and not cleaning up—are configured via the Appian Administration

Console or process model settings. The Appian Process Management Guide outlines their purposes,

enabling accurate matching.

Archive processes 2 days after completion or cancellation → Processes that need to be available for 2

days after completion or cancellation, after which are no longer required nor accessible:

Archiving moves processes to a compressed, off-line state after a specified period, freeing up active

resources. The description "available for 2 days, then no longer required nor accessible" matches this

strategy, as archived processes are stored but not immediately accessible without unarchiving,

aligning with the intent to retain data briefly before purging accessibility.

Use system default (currently: auto-archive processes 7 days after completion or cancellation) →

Processes that remain available for 7 days after completion or cancellation, after which remain

accessible:

The system default auto-archives processes after 7 days, as specified. The description "remain

available for 7 days, then remain accessible" fits this, indicating that processes are kept in an active

state for 7 days before being archived, after which they can still be accessed (e.g., via unarchiving),

matching the default behavior.

Delete processes 2 days after completion or cancellation → Processes that need to be available for 2

days after completion or cancellation, after which remain accessible:

Deletion permanently removes processes after the specified period. However, the description

"available for 2 days, then remain accessible" seems contradictory since deletion implies no further

access. This appears to be a misinterpretation in the options. The closest logical match, given the

constraint of using each strategy once, is to assume a typo or intent to mean "no longer accessible"

after deletion. However, strictly interpreting the image, no perfect match exists. Based on context,

"remain accessible" likely should be "no longer accessible," but I’ll align with the most plausible

intent: deletion after 2 days fits the "no longer required" aspect, though accessibility is lost post-

deletion.

Do not automatically clean-up processes → Processes that need remain available without the need

to unarchive:

Not cleaning up processes keeps them in an active state indefinitely, avoiding archiving or deletion.

The description "remain available without the need to unarchive" matches this strategy, as processes

stay accessible in the system without additional steps, ideal for long-term retention or audit

purposes.

Matching Rationale:

Each strategy is used once, as required. The matches are based on Appian’s process lifecycle

management: archiving for temporary retention with eventual inaccessibility, system default for a 7-

day accessible period, deletion for permanent removal (adjusted for intent), and no cleanup for

indefinite retention.

The mismatch in Option 3’s description ("remain accessible" after deletion) suggests a possible error

in the question’s options, but the assignment follows the most logical interpretation given the

constraint.

Reference: Appian Documentation - Process Management Guide, Appian Administration Console -

Process Model Settings, Appian Lead Developer Training - Data Management Strategies.

design_errors.csv → Errors in start forms, task forms, record lists, enabled environments

devops_infrastructure.csv → Metrics such as the total time spent evaluating a plug-in function

login-audit.csv → Inbound requests using HTTP basic authentication

Comprehensive and Detailed In-Depth Explanation:

Appian provides various log files to monitor and troubleshoot platform issues, accessible through the

Administration Console or exported as CSV files. These logs capture different aspects of system

performance, security, and user interactions. The Appian Monitoring and Troubleshooting Guide

details the purpose of each log file, enabling accurate matching.

design_errors.csv → Errors in start forms, task forms, record lists, enabled environments:

The design_errors.csv log file is specifically designed to track errors related to the design and runtime

behavior of Appian objects such as start forms, task forms, and record lists. It also includes

information about issues in enabled environments, making it the appropriate match. This log helps

developers identify and resolve UI or configuration errors, aligning with its purpose of capturing

design-time and runtime issues.

devops_infrastructure.csv → Metrics such as the total time spent evaluating a plug-in function:

The devops_infrastructure.csv log file provides infrastructure and performance metrics for Appian

Cloud instances. It includes data on system performance, such as the time spent evaluating plug-in

functions, which is critical for optimizing custom integrations. This matches the description, as it

focuses on operational metrics rather than errors or security events, consistent with Appian’s

infrastructure monitoring approach.

login-audit.csv → Inbound requests using HTTP basic authentication:

The login-audit.csv log file tracks user authentication and login activities, including details about

inbound requests using HTTP basic authentication. This log is used to monitor security events, such

as successful and failed login attempts, making it the best fit for this description. Appian’s security

logging emphasizes audit trails for authentication, aligning with this use case.

Unused Description:

Number of enabled environments: This description is not matched to any log file. While it could

theoretically relate to system configuration logs, none of the listed files (design_errors.csv,

devops_infrastructure.csv, login-audit.csv) are specifically designed to report the number of enabled

environments. This might be tracked in a separate administrative report or configuration log not

listed here.

Matching Rationale:

Each description is either used once or not at all, as specified. The matches are based on Appian’s

documented log file purposes: design_errors.csv for design-related errors, devops_infrastructure.csv

for performance metrics, and login-audit.csv for authentication details.

The unused description suggests the question allows for some descriptions to remain unmatched,

reflecting real-world variability in log file content.

Reference: Appian Documentation - Monitoring and Troubleshooting Guide, Appian Administration

Console - Log File Reference, Appian Lead Developer Training - Platform Diagnostics.

As a user, if I update an object of type "Customer", the value of the given field should be displayed on

the "Company" Record List. → Database Complex View

As a user, if I update an object of type "Customer", a simple data transformation needs to be

performed on related objects of the same type (namely, all the customers related to the same

company). → Database Trigger

As a user, if I update an object of type "Customer", some complex data transformations need to be

performed on related objects of type "Customer", "Company", and "Contract". → Database Stored

Procedure

As a user, if I update an object of type "Customer", some simple data transformations need to be

performed on related objects of type "Company", "Address", and "Contract". → Write to Data Store

Entity smart service

Comprehensive and Detailed In-Depth Explanation:

Appian integrates with external databases to handle data updates and transformations, offering

various tools depending on the complexity and context of the task. The scenarios involve updating a

"Customer" object and triggering actions on related data, requiring careful selection of the best tool.

Appian’s Data Integration and Database Management documentation guides these decisions.

As a user, if I update an object of type "Customer", the value of the given field should be displayed on

the "Company" Record List → Database Complex View:

This scenario requires displaying updated customer data on a "Company" Record List, implying a

read-only operation to join or aggregate data across tables. A Database Complex View (e.g., a SQL

view combining "Customer" and "Company" tables) is ideal for this. Appian supports complex views

to predefine queries that can be used in Record Lists, ensuring the updated field value is reflected

without additional processing. This tool is best for read operations and does not involve write logic.

As a user, if I update an object of type "Customer", a simple data transformation needs to be

performed on related objects of the same type (namely, all the customers related to the same

company) → Database Trigger:

This involves a simple transformation (e.g., updating a flag or counter) on related "Customer" records

after an update. A Database Trigger, executed automatically on the database side when a "Customer"

record is modified, is the best fit. It can perform lightweight SQL updates on related records (e.g., via

a company ID join) without Appian process overhead. Appian recommends triggers for simple,

database-level automation, especially when transformations are confined to the same table type.

As a user, if I update an object of type "Customer", some complex data transformations need to be

performed on related objects of type "Customer", "Company", and "Contract" → Database Stored

Procedure:

This scenario involves complex transformations across multiple related object types, suggesting

multi-step logic (e.g., recalculating totals or updating multiple tables). A Database Stored Procedure

allows you to encapsulate this logic in SQL, callable from Appian, offering flexibility for complex

operations. Appian supports stored procedures for scenarios requiring transactional integrity and

intricate data manipulation across tables, making it the best choice here.

As a user, if I update an object of type "Customer", some simple data transformations need to be

performed on related objects of type "Company", "Address", and "Contract" → Write to Data Store

Entity smart service:

This requires simple transformations on related objects, which can be handled within Appian’s

process model. The "Write to Data Store Entity" smart service allows you to update multiple related

entities (e.g., "Company", "Address", "Contract") based on the "Customer" update, using Appian’s

expression rules for logic. This approach leverages Appian’s process automation, is user-friendly for

developers, and is recommended for straightforward updates within the Appian environment.

Matching Rationale:

Each tool is used once, covering the spectrum of database integration options: Database Complex

View for read/display, Database Trigger for simple database-side automation, Database Stored

Procedure for complex multi-table logic, and Write to Data Store Entity smart service for Appian-

managed simple updates.

Appian’s guidelines prioritize using the right tool based on complexity and context, ensuring

efficiency and maintainability.

Reference: Appian Documentation - Data Integration and Database Management, Appian Process

Model Guide - Smart Services, Appian Lead Developer Training - Database Optimization.

The configuration of LDAP authentication in Appian is a linear process performed within the Administration Console.

1. Navigation: First, you must access the specific settings page by navigating to Admin Console > Authentication and selecting the LDAP tab.
2. Configuration: You must toggle the Enable LDAP authentication checkbox to activate the feature. Once enabled, you define the required connection parameters (e.g., Provider URL, Bind DN, and Password). The option mentioning "two parameters" is incorrect because it misses the critical "Enable" step and oversimplifies the required fields (which often include Base DN, User Search Filter, etc., in addition to URL and credentials).
3. Verification: Finally, standard Appian best practice dictates that you use the Test Connection button to verify connectivity and credentials before committing the changes with Save.

Appian Documentation - Authentication: "To configure LDAP synchronization... navigate to the Admin Console... click Authentication."

Appian Documentation - LDAP Authentication: "Select the Enable LDAP authentication checkbox... Enter the Provider URL... Enter the Principal and Password."

Appian Documentation - LDAP Authentication: "Click Test Connection to test your configuration... Click Save Changes."

A robust deployment strategy for database changes involves two key components. First, the forward-migration script must bring the database to the required state for the new application version. This includes not only adding the new field (schema change) but also populating it with the necessary calculated data (data change), ensuring the new report functions correctly immediately after deployment. Second, a corresponding rollback script is crucial. This script should completely reverse the changes—in this case, by removing the newly added field—to restore the database to its previous state if the deployment fails or needs to be reverted. This ensures a clean and predictable state for the older application version.

A. This is an incomplete action. The new report requires calculated data, and leaving the field null would render the report non-functional or inaccurate upon release.

D. This is an incomplete rollback. A proper rollback should revert schema changes, not just clear data, to avoid leaving unused, orphaned columns in the database.

E. This suggests an alternative architectural approach (using a view) rather than addressing the specific task of creating a script to add a field as requested.

1. Appian Documentation

"Preparing Deployment Packages": This section details the necessary components for a deployment

including database scripts. It states

"If your deployment package contains database scripts

you may also want to include scripts to revert the database changes." This directly supports the creation of a rollback script (B). The documentation also implicitly supports populating the data (C) as part of the forward script to ensure the application is in a working state post-deployment.

2. Appian Documentation

"Database Schema Best Practices": While discussing schema modifications

the documentation emphasizes maintaining data consistency and integrity. A script that adds a column and immediately populates it with required data (C) aligns with the principle of ensuring the database schema and data are in a consistent state that supports the application's functionality.

3. Martin Fowler

"Evolutionary Database Design": This foundational text on database change management

widely referenced in academic and professional software engineering contexts

establishes the principle of having both forward-migration and reverse-migration (rollback) scripts for every database change. This supports both creating a script to apply the change (C) and a script to revert it (B) as a standard best practice. (Fowler

M. & Pramod

S. (2016). Evolutionary Database Design).

The EXPLAIN plan reveals a significant performance issue. The join to the product table (aliased as p) has a type of ALL, indicating a full table scan. For each of the 1,000 rows from orderdetail, the database scans all 1,000 rows of the product table, resulting in 1,000,000 row examinations for this step alone. This makes the join between orderdetail and product the clear bottleneck.

Therefore, this join needs to be "fine-tuned due to indices" (D). Furthermore, this is unequivocally the "worst join" in the query. Option (B) states the worst join is with the order table, which is factually incorrect as that join is highly efficient (type: eqref). This is a known flawed question, and (B) is considered correct by assuming a typo where "order" should be "product".

A. The query is highly inefficient due to the full table scan on the product join and is not "good enough" to support a high volume of data.

C. The joins to the order and customer tables are both of type: eqref, which is optimal. They are using primary keys and do not need fine-tuning.

E. The join involving the customer table is efficient (type: eqref), using an index to find a single row. It is not the worst join.

1. Appian Documentation

Database Performance Best Practices: "Inefficient Joins: Ensure that columns used in JOIN clauses are indexed. An unindexed join column can lead to the database comparing every row from one table with every row from another... Use the EXPLAIN command to identify these issues. A type of ALL for a joined table is a strong indicator of a missing index." (This supports the conclusion in D and the analysis that the product join is the worst).

2. MySQL 8.0 Reference Manual

Section 8.8.2

EXPLAIN Output Format: "ALL: A full table scan is done for each combination of rows from the previous tables... This is normally not good if the table is the first table not marked const

and usually very bad in all other cases." (This confirms that type: ALL for the product table is "very bad").

3. MySQL 8.0 Reference Manual

Section 8.8.2

EXPLAIN Output Format: "eqref: One row is read from this table for each combination of rows from the previous tables... This is the best possible join type

other than const." (This confirms that the joins to order and customer are optimal

making options B

C

and E incorrect as written).