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

 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 question is about a sign that an application’s performance is degrading and should be addressed with changes to the application design. The following is a sign of this:

• Three of the top five most executed process models have a low completion percentage. This means that a large proportion of the process instances are not reaching the end event, either because they are taking too long to complete, or because they are encountering errors or exceptions. This can affect the performance of the application, as it can consume more memory and resources, and reduce the availability and reliability of the application. You should review the process model design and identify the causes of the low completion rate, and make changes to improve the process efficiency and error handling.

The following are not signs of performance degradation that require changes to the application design:

• Integration calls to an external system are consistently returning an HTTP status code of 500. This means that the external system is experiencing an internal server error, which is not related to the application design. You should contact the external system provider and report the issue, or implement a fallback or retry mechanism in your integration logic.
• The number of tasks assigned to users has increased from 1 per day to 5 per day. This means that the workload or demand for the application has increased, which is not necessarily a sign of performance degradation. You should monitor the task completion rate and user feedback to see if the increase in tasks is affecting the user experience or satisfaction, and adjust the task assignment or prioritization logic if needed.
• The number of objects in the Application has increased from about 100 to about 500. This means that the application has grown in size and complexity, which is not necessarily a sign of performance degradation. You should follow the best practices for application design and maintenance, such as using folders, prefixes, dependencies, and documentation, to keep the application organized and manageable.

References:

• Process Model Metrics
• HTTP Status Codes
• Task Report
• Application Design

Activity chaining is a feature that allows users to complete multiple tasks in a row without returning to their task list. However, activity chaining can also have some drawbacks, such as increased memory consumption, longer transaction times, and reduced user feedback. Therefore, some actions can be taken to make the process model more efficient, such as:

• Shorten long process chains by combining transactions into the smallest number of nodes. This can reduce the memory footprint and the database load of the process model.
• Avoid chaining system nodes like Integrations. These nodes can have unpredictable execution times and can cause timeouts or errors if chained. It is better to use asynchronous integrations or message events to decouple the process flow from external systems.
• Move transactions that can be done asynchronously outside of the chain. This can improve the responsiveness of the process model and allow parallel processing of independent tasks.

Therefore, the correct answers are B, C, and D.

References:

• Activity Chaining
• Performance Best Practices

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 most efficient way to achieve the integration between the third-party document scanner and the Appian record list is to create a view between both the [appian].[document] and [appian].[caseData] tables to feed the record. A view is a virtual table that is defined by a query and does not store any data. It can join, filter, aggregate, or transform data from one or more tables and present it in a desired format. A view can be used to simplify complex queries, provide security, or enhance performance. By creating a view, the record can show data from both tables without duplicating or copying any data. Therefore, the correct answer is C.

References:

• Relational Database Guidance
• Views

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