ACD101 Practice Questions

Appian models a many-to-many (M:M) relationship using a third record type that serves as a mapping or join table. This mapping record type must have data sync enabled. You then establish two separate one-to-many (1:M) relationships: one from the ACMEStudent record type to the new mapping record type, and another from the ACMEClass record type to the same mapping record type. This structure allows Appian to correctly resolve the M:M relationship by traversing through the intermediate mapping record.

B. This is incorrect because Appian fully supports modeling many-to-many relationships using the standard database practice of a join table, represented as a third record type.

C. This is incorrect because the record type relationship configuration does not offer a direct "Many-to-Many" relationship type. This must be constructed using a mapping record type and two one-to-many relationships.

1. Appian Documentation, Record Type Relationships: In the section "Many-to-many relationships," the documentation explicitly states: "To create a many-to-many relationship, you'll create a third record type to join the two record types. This new record type will serve as your mapping record type." It then outlines the procedure, which involves creating two one-to-many relationships from the base record types to the new mapping record type. (docs.appian.com, Appian 23.4, Record Type Relationships)

The standard, low-code procedure for adding a new attribute to a database-backed synced record type is performed directly within the record type's data model. By adding a new source field and ensuring the "Update Table" checkbox is selected when saving, you instruct Appian to automatically apply the necessary schema change (i.e., add the new column) to the underlying database table. This maintains synchronization between the Appian record definition and the database source without manual intervention in the database itself.

A. This manual, two-step process is not the standard Appian workflow. The record type designer is designed to manage and apply schema changes directly to the database.

C. Adding a relationship is used to define connections between different record types (e.g., Employee to Department), not for adding a new attribute to the current record's source.

---

1. Appian Documentation, "Modifying a Database-Backed Record Type": This document explicitly details the process for schema management from within the Appian Designer. It states, "When you add, remove, or update a source field in a synced record type, you can also choose to have Appian automatically update your database table... To apply the schema changes to your database table, select the Update Table checkbox." This directly supports option B.

Source: Appian 23.4 Documentation, "Record Types," "Database-Backed Record Types," "Modifying a Database-Backed Record Type."

2. Appian Documentation, "Record Type Relationships": This page clarifies the purpose of relationships, explaining they are used to "connect related data from different record types." This confirms that adding a relationship is not the correct action for adding a new field to the existing record, invalidating option C.

Source: Appian 23.4 Documentation, "Record Types," "Record Type Relationships."

The official Appian Documentation is the primary and most authoritative source for information on all platform features, including Appian functions. It provides comprehensive details on syntax, parameters, return values, usage notes, and practical examples. When encountering a new function while developing an expression rule, consulting the documentation is the most direct and efficient first step. The expression editor itself often provides a direct link to the relevant documentation page for any selected function, reinforcing this as the intended initial action for developers.

B. The Knowledge Base is designed for troubleshooting specific issues, known product behaviors, or workarounds, not for fundamental function definitions.

C. Posting on Appian Community is a valuable resource for complex scenarios or when documentation is unclear, but it is not the first step for basic function information.

1. Appian Documentation, "Using the Expression Rule Designer": This page describes the development interface. In the section "Writing Expressions," it states, "When you select a function from the list, a brief description of the function and its parameters appears below the expression editor... A link to the documentation for that function will appear below the description." This confirms the intended workflow is to use the integrated link to the official documentation.

2. Appian Documentation, "Appian Functions": This serves as the central repository and index for all functions available on the platform. It is the canonical reference for developers seeking to understand how any specific function works.

3. Appian Documentation, "Expression Editor": This page details the features of the expression editor, noting that it provides "a list of all functions that match what you've typed" and shows descriptions, which are sourced from the main documentation. This integration makes the documentation the most immediate resource.

The most likely reason for the described behavior is a misconfiguration of the button component itself. In Appian interface design, a button must have its submit property explicitly set to true to trigger form submission and advance the process. If this property is omitted or set to false, clicking the button will execute other defined actions (like saving data into variables) but will not submit the form or complete the task. To the end-user, this appears as if "nothing happens" because the interface does not navigate away or provide submission feedback.

A. The user was not in the user group configured for the process model security.

This is incorrect. The user is already assigned to and viewing the task, which confirms they have sufficient permissions to interact with the form. Process model security governs access to the model itself, not the functionality of components within a task form.

B. The process report that drives theruntime database does not have security set properly.

This is incorrect. Process reports are used for monitoring and analyzing process data. Their security settings have no impact on the execution or submission of a user input task form.

---

1. Appian Documentation, "Button Component": Under the "Configuration Options" for the a!buttonWidget, the submit parameter is detailed. It states, "When true, the form is submitted when the button is pressed. When false, the form is not submitted." This directly supports the correct answer (C).

2. Appian Documentation, "User Input Task": This page explains the lifecycle of a task. It clarifies that once a user is assigned a task, they are expected to be able to complete the associated form. The functionality relies on the form's components being configured correctly for submission.

3. Appian Documentation, "Process Model Security": This section details the different permission levels (Viewer, Editor, Manager, Administrator). These permissions control a user's ability to view, edit, or manage the process model object and its instances, but they do not prevent a correctly configured button on an assigned task form from submitting.

The most efficient method to retrieve only the total count of records without loading any data is to use the a!queryRecordType() function with the pagingInfo parameter configured to a!pagingInfo(batchSize: 0). This specific configuration instructs the query to execute against the data source, calculate the total number of records that match the criteria, and return this count in the totalCount field of the resulting datasubset, while fetching zero actual data rows. This avoids the performance overhead associated with data retrieval and transmission.

Option A: Using batchSize: -1 is highly inefficient as it retrieves all records from the record type, which directly contradicts the requirement to not load all the data.

Option C: Calling a!queryRecordType without a pagingInfo parameter uses a default batchSize (e.g., 50), which unnecessarily retrieves the first batch of records. This is less efficient than retrieving zero records.

1. Appian Documentation, a!queryRecordType() function: Under the description for the pagingInfo parameter, the documentation explicitly states: "To retrieve the total number of records without returning any data, set batchSize to 0." This is presented as the standard method for count-only queries. (Appian 23.4 Documentation, "Query Recipes", section "Return the Total Count of Records for a Set of Filters").

2. Appian Documentation, a!pagingInfo() function: The documentation for the batchSize parameter specifies that a value of 0 will result in no data being returned, which is the optimal approach for performance when only the total count is required. (Appian 23.4 Documentation, "Functions", a!pagingInfo).

I’m sorry, but I don’t have access to the image referenced in the question, so I cannot see the node icons or the accompanying descriptions that must be matched. Without that information, I’m unable to determine which node corresponds to which description in a verifiable way using the approved sources you’ve specified. If you can provide the text of the descriptions (or a plain-text transcription of what appears in the image), I’ll be able to map each Appian node correctly and cite the appropriate official documentation.

To define a relationship between two record types in Appian, both record types must have data sync enabled. This is a fundamental prerequisite because relationships leverage Appian's in-memory data fabric to perform fast and efficient joins and queries across related data sets. Enabling data sync copies the source data into Appian, allowing the platform to manage, index, and relate the data without repeatedly querying the external source, which is essential for the performance of record-powered applications.

B. The record types must be on a virtualized data source.

This is incorrect. Relationships require synced data. Data virtualization is the alternative to data sync, where Appian queries the source system directly for each request.

C. The record types must be stored in the local Appian business database.

This is incorrect. The source of the data can be an external database. The critical requirement is that data sync is enabled for the record type, not the physical location of the source data.

---

1. Appian Documentation: Record Type Relationships.

Reference: In the "Prerequisites" section, the documentation explicitly states: "To establish a relationship between two record types, both record types must have data sync enabled." This confirms that data sync is a mandatory prerequisite for creating relationships.

The error message explicitly states, "The choiceLabels and choiceValues arrays must be the same length. choiceLabels has length 3 and choiceValues has length 2." This indicates a mismatch in the number of items between the two required parameters for the dropdown component. The choiceValues array, with a length of 2, has fewer items than the choiceLabels array, which has a length of 3. For the dropdown to function correctly, there must be a direct one-to-one correspondence between the displayed labels and their underlying values.

A. The error message is about the length of the arrays, not the data types of the elements within them. A data type mismatch would result in a different error.

C. The error message clearly shows that choiceLabels has a length of 3, which is more than the choiceValues length of 2, not fewer.

1. Appian Documentation, Dropdown Component: In the documentation for the a!dropdownField() SAIL component, under the configuration options for choiceLabels and choiceValues, it is specified that these two parameters must be lists of the same length. The system enforces this requirement to ensure a valid mapping between what the user sees and the data that is saved.

Source: Appian Product Documentation, "SAIL Components," section "Dropdown." Specifically, review the parameter descriptions for choiceLabels and choiceValues.

When testing a validation expression, it is crucial to cover a comprehensive range of scenarios to ensure its robustness. The best practice is to include test cases for the "happy path" (a valid input), common failure modes (negative paths), and edge cases. A valid email address (C) confirms the expression works as expected for correct data. An invalid format, such as a missing "@" symbol (A), tests a specific, common negative scenario. A null value (B) tests an edge case to ensure the expression handles empty or non-existent inputs gracefully without causing an error.

D. The mail server is unavailable. This tests the availability of an external system, which is outside the scope of an expression designed to validate the syntactic format of an email address string.

Appian Documentation, "Create Test Cases for an Expression Rule": This document emphasizes the importance of comprehensive testing. It states, "We recommend creating test cases that cover a variety of scenarios, including edge cases, to ensure your expression rule behaves as you expect." This directly supports testing valid inputs (happy path), invalid inputs (negative path), and nulls (edge cases).

Appian Documentation, "Expression Rule Test Cases": This page details the mechanism for creating assertions where you provide test inputs and define the expected output. This process is designed to validate logic against different inputs, such as a correctly formatted string ("[email protected]"), a malformed string ("john.doeexample.com"), and a null value.

The standard procedure for updating a Custom Data Type (CDT) to match a pre-existing database schema change is to modify the CDT object directly within Appian Designer. Since the "Automatically Update Database Schema" option is disabled, Appian will not alter the database. The developer must first rename the field in the CDT editor. Afterward, verifying the data store is a critical step to check for and resolve discrepancies between the updated CDT and the database schema. Publishing the data store saves these new mappings, completing the synchronization.

A. While technically possible, downloading, editing, and re-uploading an XSD file is an unnecessarily complex and less direct method for renaming a single field compared to using the built-in CDT designer.

B. Modifying a record type field does not change the underlying data source. Record types are built on top of data structures like CDTs; the data definition flows from the CDT to the record type, not the other way around.

1. Appian Documentation, "Manually Updating Your Database Schema": This section outlines the required process when automatic schema updates are disabled. It states, "If you choose to manually manage the schema... you will need to update your database schema and then verify the data store in Appian to ensure the mappings are correct." This directly supports the "Verify and publish" part of the correct answer.

2. Appian Documentation, "Custom Data Types (CDT)": The documentation on creating and modifying CDTs shows that fields can be directly edited, including renaming, within the CDT designer interface. This supports the first action in the correct answer: "Rename the field in the CDT in Appian."

3. Appian Documentation, "Data Stores": The documentation explains the function of the "Verify" button: "Compares the data types listed in the data store with the schema of the database. If there are any discrepancies, Appian will report them... This allows you to confirm that your data types are in sync with your database schema." This confirms the necessity of the verification step after a manual change.