ACD200 Appian Certified Senior Developer Questions and Answers

 The metric from the data_store_details.csv file that will help you understand the number of operations against data store is Total Count. This metric represents the total number of queries, inserts, updates, deletes, and executes performed against the data store during the specified time period. You can use this metric to identify which data stores are heavily used and may need performance tuning or scaling. References: [Data Store Details Report], [Data Store Metrics]

 The context type that should be chosen for the Task Report Type is Tasks attributed to user. This is because this context type allows you to display information for pending tasks for each individual in an application. You can filter the tasks by application name, process model name, or task name. This context type also supports drilldown functionality, which enables users to view more details about a specific task or complete it directly from the report. References: Task Report Types

 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 database object that should be used to create a virtual relation in a database to query the data is a view. A view is a searchable object that is defined by a query. It does not store any data but retrieves data from one or more tables at run time, creating a virtual table and returning the data in the defined format. It is created using joins, filters, aggregations, or other SQL operations. A view can be used to simplify complex queries, provide security, or enhance performance. Therefore, the correct answer is D.

References:

• Relational Database Guidance
• Views

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 two statements about the a!queryEntity() function that are true are:

• The entity value must be given as a constant of type Data Store Entity. This is because the entity value specifies which data store entity (table or view) to query from. The value must be a constant that references an existing data store entity in Appian Designer. You cannot use a variable or an expression for this value.
• Setting the fetchTotalCount parameter to False can improve the performance of the rule. This is because setting this parameter to False tells Appian not to calculate the total number of records that match the query criteria, which can be an expensive operation for large data sets. By default, this parameter is set to True, which means Appian will return the total count along with the query results. References: a!queryEntity() Function

 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 data_store_details.csv log provides information about the performance of query entities. The log shows the time spent in three phases: extract, transform, and load. The extract phase is the time it takes to execute the SQL query on the database. The transform phase is the time it takes to convert the SQL result set into Appian data types. The load phase is the time it takes to return the data to the expression that invoked the query entity. To reduce the time spent in the transform phase, two possible actions are to reduce the number of columns returned from the query and to lower the batch size parameter of the query. These actions can decrease the amount of data that needs to be converted and transferred, which can improve the performance of the query entity. Therefore, the correct answers are B and D.

References:

• Query Entity Performance
• a!queryEntity() Function

 The best way to restrict the uploading of documents without extensions at the environment level is to enable the File Upload > Block files without an extension option under the Administration Console. This option will prevent users from uploading files that do not have a valid file extension, such as .docx, .pdf, or .png. This can help to avoid security risks and compatibility issues with unsupported file types. Therefore, the correct answer is A.

References:

• [File Upload Settings]
• [File Extensions]

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

When creating a Web API, you need to configure two items in the Administration Console: an API key and a service account. An API key is a unique identifier that is used to authenticate requests to your Web API. You can create and manage API keys in the Administration Console under Integration > API Keys. A service account is a user account that is used to execute the Web API expression rule. You can select a service account in the Administration Console under Integration > Web APIs when you create or edit a Web API. References: [Web APIs], [API Keys], [Service Accounts]

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 question is about improving the memory usage of a process model. The following are three things you can do for this purpose:

• Reduce the number of process variables. This means using fewer or smaller process variables to store data in the process model, as each process variable consumes memory and resources. You should only use process variables that are necessary for the process logic or data flow, and avoid storing redundant or temporary data in process variables.
• Avoid storing large blocks of text in process variables. This means using other methods to store or handle large blocks of text, such as documents, constants, or expression rules, rather than process variables. This can reduce the memory usage of the process model, as large blocks of text can consume a lot of memory and resources, and affect the performance or stability of Appian.
• Pass data directly to activity nodes and smart services. This means using parameters or inputs to pass data to activity nodes and smart services, rather than process variables. This can reduce the memory usage of the process model, as parameters or inputs are only evaluated when needed, and do not persist in memory.

The following are not things you can do to improve the memory usage of a process model:

• Configure process variables to be parameters. This is not possible, as process variables and parameters are different types of data elements in a process model. Process variables are used to store data throughout the process model, while parameters are used to pass data to or from a subprocess or an expression rule.
• Split large nodes into many smaller nodes. This is not advisable, as it can increase the complexity and maintenance overhead of the process model, and may not reduce the memory usage significantly. You should only split nodes when it makes sense for the process logic or functionality, and not for the sake of reducing node size.

References:

• Process Variables
• Documents
• Constants
• Expression Rules
• Parameters

When troubleshooting a process model instance with an error in a node, two options that can provide more information about the error are to view the Process Details dialog and to view the properties dialog of the affected node. The Process Details dialog shows the status, history, and variables of the process instance, as well as any errors or warnings that occurred during the execution. The properties dialog of the affected node shows the configuration, inputs, outputs, and expressions of the node, as well as any errors or warnings that occurred during the evaluation. These options can help to identify the cause and location of the error, and to apply any necessary fixes. Therefore, the correct answers are B and D.

References:

• [Process Details Dialog]
• [Properties Dialog]

 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

The three actions that can be taken to minimize the performance impact of the Tempo report are:

• Limit the number of series values and categories in the report. This is because having too many series values and categories can make the report difficult to read and render, as well as increase the amount of data that needs to be transferred from the database to Appian. A good practice is to limit the number of series values to 10 or less, and the number of categories to 20 or less.
• Use local variables in your report interface to avoid redundant database queries. This is because local variables can store the results of database queries and reuse them in multiple places within the interface, reducing the number of times the database is accessed. A good practice is to use local variables for common filters, aggregations, or calculations that are used in multiple charts or grids.
• Perform aggregation in the database using a view prior to reading the data into Appian. This is because performing aggregation in the database can reduce the amount of data that needs to be transferred from the database to Appian, as well as leverage the database’s optimization capabilities. A good practice is to create a view in the database that performs the aggregation and then query that view using Appian. References: Report Performance Best Practices

The question is about approving or rejecting an incoming deployment. The following roles allow you to do so:

• Specified Reviewer Group: This is a group that can be specified by the application administrator when creating a deployment package. Members of this group can approve or reject the deployment package in the target environment.
• System Administrators: This is a group that has full access and control over all applications and system settings in Appian. Members of this group can approve or reject any deployment package in any environment.
• Application Administrators Group: This is a group that has full access and control over a specific application in Appian. Members of this group can approve or reject any deployment package for their application in any environment.

The following roles do not allow you to approve or reject an incoming deployment:

• Application Viewers: This is a group that has read-only access to a specific application in Appian. Members of this group cannot approve or reject any deployment package for their application in any environment.
• Application Editors: This is a group that has edit access to a specific application in Appian. Members of this group can create and export deployment packages for their application in any environment, but they cannot approve or reject them.

References:

• Deploying Applications
• Application Roles

In Scrum, the product owner is the person who represents the voice of the customer and the stakeholders. The product owner is responsible for defining and prioritizing the product backlog, which is a list of features, requirements, enhancements, and fixes that need to be delivered by the team. The product owner collaborates with the team and the scrum master to ensure that the product backlog is clear, valuable, and aligned with the product vision and goals.