The best practice for reusing common UI components across multiple applications is to create shared objects, which are objects that can be referenced by other applications without being copied or duplicated. This way, any changes made to the shared object will be reflected in all applications that use it, ensuring consistency and maintainability. Therefore, instead of creating a duplicate version of the customer section for the new application, the developer should convert the original customer section into a shared object and reference it from both applications. Verified References: Appian Documentation, section “Shared Objects”.

Functional acceptance criteria are the conditions that a user story must satisfy to be accepted by the user or stakeholder. They should be specific, measurable, achievable, relevant, and testable. In this case, two functional acceptance criteria that would be considered ‘good’ are:

• The user will receive an email notification when their order is completed. This is a specific, measurable, achievable, relevant, and testable criterion that describes a feature that the user needs to be informed of their order status.
• The user cannot submit the form without filling out all required fields. This is a specific, measurable, achievable, relevant, and testable criterion that describes afeature that the user needs to provide valid and complete information for their order.

The other options are not as good. Option A, the user will click Save, and the order information will be saved in the ORDER table and have audit history, is not a functional acceptance criterion, but rather a technical implementation detail that is not relevant or visible to the user. Option C, the system must handle up to 500 unique orders per day, is not a functional acceptance criterion, but rather a non-functional requirement that describes a performance or quality attribute of the system.

When creating a script to add a new field to a table, you should consider two actions:

• Create a rollback script that removes the field. A rollback script is a script that can undo the changes made by the original script, in case something goes wrongor the changes need to be reverted. A rollback script is a good practice to have, as it can help to restore the previous state of the database and avoid any errors or inconsistencies. In this case, the rollback script should remove the new field from the table, and any other changes that were made by the original script.
• Create a script that adds the field and then populate it. A script that adds the field and then populate it is a script that can create the new field in the table, and then fill it with data from another table or source. This way, you can ensure that the new field has valid and consistent data, and that it can be used by the report in the upcoming release. In this case, the script should add the new field to the customer table, and then populate it with data from another table that contains the data used in the calculation.

To build a large scale acquisition application for a prominent customer, you should design for multiple processes and forms, while minimizing repeated code. One way to do this is to create a common objects application, which is a shared application that contains reusable components, such as rules, constants, interfaces, integrations, or data types, that can be used by multiple applications. This way, you can avoid duplication and inconsistency of code, and make it easier to maintain and update your applications. You can also use the common objects application to define common standards and best practices for your application development teams, such as naming conventions, coding styles, or documentation guidelines. Verified References: [Appian Best Practices], [Appian Design Guidance]

To design a complex Appian integration to call a RESTful API, you need to have some prerequisites, such as:

• Define the HTTP method that the integration will use. The HTTP method is the action that the integration will perform on the API, such as GET, POST, PUT, PATCH, or DELETE. The HTTP method determines how the data will be sent and received by the API, and what kind of response will be expected.
• Understand the content of the expected body, including each field type and their limits. The body is the data that the integration will send to the API, or receive from the API, depending on the HTTP method. The body can be in different formats, such as JSON, XML, or form data. You need to understand how to structure the body according to the API specification, and what kind of data types and values are allowed for each field.
• Understand the different error codes managed by the API and the process of error handling in Appian. The error codes are the status codes that indicate whether the API request was successful or not, and what kind of problem occurred if not. The error codes can range from 200 (OK) to 500 (Internal Server Error), and each code has a different meaning and implication. You need to understand how to handle different error codes in Appian, and how to display meaningful messages to the user or log them for debugging purposes.

The other two options are not prerequisites for designing the integration, but rather considerations for implementing it.

• Understand whether this integration will be used in an interface or in a process model. This is not a prerequisite, but rather a decision that you need to make based on your application requirements and design. You can use an integration either in an interface or in a process model, depending on where you need to call the API and how you want to handle the response. For example, if you need to update a case in real-time based on user input, you may want to use an integration in an interface. If you need to update a case periodically based on a schedule or an event, you may want to use an integration in a process model.
• Understand the business rules to be applied to ensure the business logic of the data. This is not a prerequisite, but rather a part of your application logic that you need to implement after designing the integration. You need to apply business rules to validate, transform, or enrich the data that you send or receive from the API, according to your business requirements and logic. For example, you may need to check if the case status is valid before updating it in the legacy system, or you may need to add some additional information to the case data before displaying it in Appian.

The three things that might help to address the findings of the Health Check report are:

• B. Optimize the database execution using standard database performance troubleshooting methods and tools (such as query execution plans). This can help to identify and eliminate any bottlenecks or inefficiencies in the database queries that are causing slow query rules or slow write to data store nodes.
• C. Reduce the size and complexity of the inputs. If you are passing in a list, consider whether the data model can be redesigned to pass single values instead. This can help to reduce the amount of data that needs to be transferred or processed by the database, which can improve the performance and speed of the queries or writes.
• E. Use smaller CDTs or limit the fields selected in a!queryEntity(). This can help to reduce the amount of data that is returned by the queries, which can improve the performance and speed of the rules that use them.

The other options are incorrect for the following reasons:

• A. Reduce the batch size for database queues to 10. This might not help to address the findings, as reducing the batch size could increase the number of transactions and overhead for the database, which could worsen the performance and speed of the queries or writes.
• D. Optimize the database execution. Replace the new with a materialized view. This might not help to address the findings, as replacing a view with a materialized view could increase the storage space and maintenance cost for the database, which could affect the performance and speed of the queries or writes. Verified References: Appian Documentation, section “Performance Tuning”.