[2025年05月] 合格させるACD301試験一発合格、最新のACD301 の提供する試験問題 [Q28-Q51]

[2025年05月] 合格させるACD301試験一発合格、最新のACD301 Fast2testの提供する試験問題

Lead Developer問題集でACD301試験の完全版解答試験学習ガイド

質問 # 28
You are the lead developer for an Appian project, in a backlog refinement meeting. You are presented with the following user story:
"As a restaurant customer, I need to be able to place my food order online to avoid waiting in line for takeout." Which two functional acceptance criteria would you consider 'good'?

A. The system must handle up to 500 unique orders per day.
B. The user will receive an email notification when their order is completed.
C. The user cannot submit the form without filling out all required fields.
D. The user will click Save, and the order information will be saved in the ORDER table and have audit history.

正解：C、D

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, defining "good" functional acceptance criteria for a user story requires ensuring they are specific, testable, and directly tied to the user's need (placing an online food order to avoid waiting in line). Good criteria focus on functionality, usability, and reliability, aligning with Appian's Agile and design best practices. Let's evaluate each option:
* A. The user will click Save, and the order information will be saved in the ORDER table and have audit history:This is a "good" criterion. It directly validates the core functionality of the user story-placing an order online. Saving order data in the ORDER table (likely via a process model or Data Store Entity) ensures persistence, and audit history (e.g., using Appian's audit logs or database triggers) tracks changes, supporting traceability and compliance. This is specific, testable (e.g., verify data in the table and logs), and essential for the user's goal, aligning with Appian's data management and user experience guidelines.
* B. The user will receive an email notification when their order is completed:While useful, this is a
"nice-to-have" enhancement, not a core requirement of the user story. The story focuses on placing an order online to avoid waiting, not on completion notifications. Email notifications add value but aren't essential for validating the primary functionality. Appian's user story best practices prioritize criteria tied to the main user need, making this secondary and not "good" in this context.
* C. The system must handle up to 500 unique orders per day:This is a non-functional requirement (performance/scalability), not a functional acceptance criterion. It describes system capacity, not specific user behavior or functionality. While important for design, it's not directly testable for the user story's outcome (placing an order) and isn't tied to the user's experience. Appian's Agile methodologies separate functional and non-functional requirements, making this less relevant as a
"good" criterion here.
* D. The user cannot submit the form without filling out all required fields:This is a "good" criterion. It ensures data integrity and usability by preventing incomplete orders, directly supporting the user's ability to place a valid online order. In Appian, this can be implemented using form validation (e.g., required attributes in SAIL interfaces or process model validations), making it specific, testable (e.g., verify form submission fails with missing fields), and critical for a reliable user experience. This aligns with Appian's UI design and user story validation standards.
Conclusion: The two "good" functional acceptance criteria are A (order saved with audit history) and D (required fields enforced). These directly validate the user story's functionality (placing a valid order online), are testable, and ensure a reliable, user-friendly experience-aligning with Appian's Agile and design best practices for user stories.
References:
* Appian Documentation: "Writing Effective User Stories and Acceptance Criteria" (Functional Requirements).
* Appian Lead Developer Certification: Agile Development Module (Acceptance Criteria Best Practices).
* Appian Best Practices: "Designing User Interfaces in Appian" (Form Validation and Data Persistence).

質問 # 29
You need to export data using an out-of-the-box Appian smart service. Which two formats are available (or data generation?

A. XML
B. CSV
C. Excel
D. JSDN

正解：B、C

解説：
The two formats that are available for data generation using an out-of-the-box Appian smart service are:
* A. CSV. This is a comma-separated values format that can be used to export data in a tabular form, such as records, reports, or grids. CSV files can be easily opened and manipulated by spreadsheet applications such as Excel or Google Sheets.
* C. Excel. This is a format that can be used to export data in a spreadsheet form, with multiple worksheets, formatting, formulas, charts, and other features. Excel files can be opened by Excel or other compatible applications.
The other options are incorrect for the following reasons:
* B. XML. This is a format that can be used to export data in a hierarchical form, using tags and attributes to define the structure and content of the data. XML files can be opened by text editors or XML parsers, but they are not supported by the out-of-the-box Appian smart service for data generation.
* D. JSON. This is a format that can be used to export data in a structured form, using objects and arrays to represent the data. JSON files can be opened by text editors or JSON parsers, but they are not supported by the out-of-the-box Appian smart service for data generation. Verified References: Appian Documentation, section "Write to Data Store Entity" and "Write to Multiple Data Store Entities".

質問 # 30
You are in a backlog refinement meeting with the development team and the product owner. You review a story for an integration involving a third-party system. A payload will be sent from the Appian system through the integration to the third-party system. The story is 21 points on a Fibonacci scale and requires development from your Appian team as well as technical resources from the third-party system. This item is crucial to your project's success. What are the two recommended steps to ensure this story can be developed effectively?

A. Maintain a communication schedule with the third-party resources.
B. Acquire testing steps from QA resources.
C. Break down the item into smaller stories.
D. Identify subject matter experts (SMEs) to perform user acceptance testing (UAT).

正解：A、C

解説：
Comprehensive and Detailed In-Depth Explanation:This question involves a complex integration story rated at 21 points on the Fibonacci scale, indicating significant complexity and effort. Appian Lead Developer best practices emphasize effective collaboration, risk mitigation, and manageable development scopes for such scenarios. The two most critical steps are:
* Option C (Maintain a communication schedule with the third-party resources):Integrations with third-party systems require close coordination, as Appian developers depend on external teams for endpoint specifications, payload formats, authentication details, and testing support. Establishing a regular communication schedule ensures alignment on requirements, timelines, and issue resolution.
Appian's Integration Best Practices documentation highlights the importance of proactive communication with external stakeholders to prevent delays and misunderstandings, especially for critical project components.
* Option D (Break down the item into smaller stories):A 21-point story is considered large by Agile standards (Fibonacci scale typically flags anything above 13 as complex). Appian's Agile Development Guide recommends decomposing large stories into smaller, independently deliverable pieces to reduce risk, improve testability, and enable iterative progress. For example, the integration could be split into tasks like designing the payload structure, building the integration object, and testing the connection- each manageable within a sprint. This approach aligns with the principle of delivering value incrementally while maintaining quality.
* Option A (Acquire testing steps from QA resources):While QA involvement is valuable, this step is more relevant during the testing phase rather than backlog refinement or development preparation. It's not a primary step for ensuring effective development of the story.
* Option B (Identify SMEs for UAT):User acceptance testing occurs after development, during the validation phase. Identifying SMEs is important but not a key step in ensuring the story is developed effectively during the refinement and coding stages.
By choosingCandD, you address both the external dependency (third-party coordination) and internal complexity (story size), ensuring a smoother development process for this critical integration.
References:Appian Lead Developer Training - Integration Best Practices, Appian Agile Development Guide
- Story Refinement and Decomposition.

質問 # 31
As part of an upcoming release of an application, a new nullable field is added to a table that contains customer data. The new field is used by a report in the upcoming release and is calculated using data from another table.
Which two actions should you consider when creating the script to add the new field?

A. Create a script that adds the field and leaves it null.
B. Add a view that joins the customer data to the data used in calculation.
C. Create a rollback script that removes the field.
D. Create a rollback script that clears the data from the field.
E. Create a script that adds the field and then populates it.

正解：C、E

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, adding a new nullable field to a database table for an upcoming release requires careful planning to ensure data integrity, report functionality, and rollback capability. The field is used in a report and calculated from another table, so the script must handle both deployment and potential reversibility. Let's evaluate each option:
* A. Create a script that adds the field and leaves it null:Adding a nullable field and leaving it null is technically feasible (e.g., using ALTER TABLE ADD COLUMN in SQL), but it doesn't address the report's need for calculated data. Since the field is used in a report and calculated from another table, leaving it null risks incomplete or incorrect reporting until populated, delaying functionality. Appian's data management best practices recommend populating data during deployment for immediate usability, making this insufficient as a standalone action.
* B. Create a rollback script that removes the field:This is a critical action. In Appian, database changes (e.g., adding a field) must be reversible in case of deployment failure or rollback needs (e.g., during testing or PROD issues). A rollback script that removes the field (e.g., ALTER TABLE DROP COLUMN) ensures the database can return to its original state, minimizing risk. Appian's deployment guidelines emphasize rollback scripts for schema changes, making this essential for safe releases.
* C. Create a script that adds the field and then populates it:This is also essential. Since the field is nullable, calculated from another table, and used in a report, populating it during deployment ensures immediate functionality. The script can use SQL(e.g., UPDATE table SET new_field = (SELECT calculated_value FROM other_table WHERE condition)) to populate data, aligning with Appian's data fabric principles for maintaining data consistency. Appian's documentation recommends populating new fields during deployment for reporting accuracy, making this a key action.
* D. Create a rollback script that clears the data from the field:Clearing data (e.g., UPDATE table SET new_field = NULL) is less effective than removing the field entirely. If the deployment fails, the field's existence with null values could confuse reports or processes, requiring additional cleanup. Appian's rollback strategies favor reverting schema changes completely (removing the field) rather than leaving it with nulls, making this less reliable and unnecessary compared to B.
* E. Add a view that joins the customer data to the data used in calculation:Creating a view (e.g., CREATE VIEW customer_report AS SELECT ... FROM customer_table JOIN other_table ON ...) is useful for reporting but isn't a prerequisite for adding the field. The scenario focuses on the field addition and population, not reporting structure. While a view could optimize queries, it's a secondary step, not a primary action for the script itself. Appian's data modeling best practices suggest views as post-deployment optimizations, not script requirements.
Conclusion: The two actions to consider are B (create a rollback script that removes the field) and C (create a script that adds the field and then populates it). These ensure the field is added with data for immediate report usability and provide a safe rollback option, aligning with Appian's deployment and data management standards for schema changes.
References:
* Appian Documentation: "Database Schema Changes" (Adding Fields and Rollback Scripts).
* Appian Lead Developer Certification: Data Management Module (Schema Deployment Strategies).
* Appian Best Practices: "Managing Data Changes in Production" (Populating and Rolling Back Fields).

質問 # 32
You are planning a strategy around data volume testing for an Appian application that queries and writes to a MySQL database. You have administrator access to the Appian application and to the database. What are two key considerations when designing a data volume testing strategy?

A. Testing with the correct amount of data should be in the definition of done as part of each sprint.
B. Data model changes must wait until towards the end of the project.
C. Data from previous tests needs to remain in the testing environment prior to loading prepopulated data.
D. The amount of data that needs to be populated should be determined by the project sponsor and the stakeholders based on their estimation.
E. Large datasets must be loaded via Appian processes.

正解：A、D

解説：
Comprehensive and Detailed In-Depth Explanation:Data volume testing ensures an Appian application performs efficiently under realistic data loads, especially when interacting with external databases like MySQL. As an Appian Lead Developer with administrative access, the focus is on scalability, performance, and iterative validation. The two key considerations are:
* Option C (The amount of data that needs to be populated should be determined by the project sponsor and the stakeholders based on their estimation):Determining the appropriate data volume is critical to simulate real-world usage. Appian's Performance Testing Best Practices recommend collaborating with stakeholders (e.g., project sponsors, business analysts) to define expected data sizes based on production scenarios. This ensures the test reflects actual requirements-like peak transaction volumes or record counts-rather than arbitrary guesses. For example, if the application will handle 1 million records in production, stakeholders must specify this to guide test data preparation.
* Option D (Testing with the correct amount of data should be in the definition of done as part of each sprint):Appian's Agile Development Guide emphasizes incorporating performance testing (including data volume) into the Definition of Done (DoD) for each sprint. This ensures that features are validated under realistic conditions iteratively, preventing late-stage performance issues. With admin access, you can query/write to MySQL and assess query performance or write latency with the specified data volume, aligning with Appian's recommendation to "test early and often."
* Option A (Data from previous tests needs to remain in the testing environment prior to loading prepopulated data):This is impractical and risky. Retaining old test data can skew results, introduce inconsistencies, or violate data integrity (e.g., duplicate keys in MySQL). Best practices advocate for a clean, controlled environment with fresh, prepopulated data per test cycle.
* Option B (Large datasets must be loaded via Appian processes):While Appian processes can load data, this is not a requirement. With database admin access, you can use SQL scripts ortools like MySQL Workbench for faster, more efficient data population, bypassing Appian process overhead.
Appian documentation notes this as a preferred method for large datasets.
* Option E (Data model changes must wait until towards the end of the project):Delaying data model changes contradicts Agile principles and Appian's iterative design approach. Changes should occur as needed throughout development to adapt to testing insights, not be deferred.
References:Appian Lead Developer Training - Performance Testing Best Practices, Appian Documentation - Data Management and Testing Strategies.

質問 # 33
You are reviewing the Engine Performance Logs in Production for a single application that has been live for six months. This application experiences concurrent user activity and has a fairly sustained load during business hours. The client has reported performance issues with the application during business hours.
During your investigation, you notice a high Work Queue - Java Work Queue Size value in the logs. You also notice unattended process activities, including timer events and sending notification emails, are taking far longer to execute than normal.
The client increased the number of CPU cores prior to the application going live.
What is the next recommendation?

A. Optimize slow-performing user interfaces.
B. Add execution and analytics shards
C. Add more application servers.
D. Add more engine replicas.

正解：D

解説：
As an Appian Lead Developer, analyzing Engine Performance Logs to address performance issues in a Production application requires understanding Appian's architecture and the specific metrics described. The scenario indicates a high "Work Queue - Java Work Queue Size," which reflects a backlog of tasks in the Java Work Queue (managed by Appian engines), and delays in unattended process activities (e.g., timer events, email notifications). These symptoms suggest the Appian engines are overloaded, despite the client increasing CPU cores. Let's evaluate each option:
* A. Add more engine replicas:This is the correct recommendation. In Appian, engine replicas (part of the Appian Engine cluster) handle process execution, including unattended tasks like timers and notifications. A high Java Work Queue Size indicates the engines are overwhelmed by concurrent activity during business hours, causing delays. Adding more engine replicas distributes the workload, reducing queue size and improving performance for both user-driven and unattended tasks. Appian's documentation recommends scaling engine replicas to handle sustained loads, especially in Production with high concurrency. SinceCPU cores were already increased (likely on application servers), the bottleneck is likely the engine capacity, not the servers.
* B. Optimize slow-performing user interfaces:While optimizing user interfaces (e.g., SAIL forms, reports) can improve user experience, the scenario highlights delays in unattended activities (timers, emails), not UI performance. The Java Work Queue Size issue points to engine-level processing, not UI rendering, so this doesn't address the root cause. Appian's performance tuning guidelines prioritize engine scaling for queue-related issues, making this a secondary concern.
* C. Add more application servers:Application servers handle web traffic (e.g., SAIL interfaces, API calls), not process execution or unattended tasks managed by engines. Increasing application servers would help with UI concurrency but wouldn't reduce the Java Work Queue Size or speed up timer
/email processing, as these are engine responsibilities. Since the client already increased CPU cores (likely on application servers), this is redundant and unrelated to the issue.
* D. Add execution and analytics shards:Execution shards (for process data) and analytics shards (for reporting) are part of Appian's data fabric for scalability, but they don't directly address engine workload or Java Work Queue Size. Shards optimize data storage and query performance, not real-time process execution. The logs indicate an engine bottleneck, not a data storage issue, so this isn't relevant.
Appian's documentation confirms shards are for long-term scaling, not immediate performance fixes.
Conclusion: Adding more engine replicas (A) is the next recommendation. It directly resolves the high Java Work Queue Size and delays in unattended tasks, aligning with Appian's architecture for handling concurrent loads in Production. This requires collaboration with system administrators to configure additional replicas in the Appian cluster.
References:
* Appian Documentation: "Engine Performance Monitoring" (Java Work Queue and Scaling Replicas).
* Appian Lead Developer Certification: Performance Optimization Module (Engine Scaling Strategies).
* Appian Best Practices: "Managing Production Performance" (Work Queue Analysis).

質問 # 34
You are on a call with a new client, and their program lead is concerned about how their legacy systems will integrate with Appian. The lead wants to know what authentication methods are supported by Appian. Which three authentication methods are supported?

A. CAC
B. OAuth
C. Biometrics
D. API Keys
E. SAML
F. Active Directory

正解：B、E、F

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, addressing a client's concerns about integrating legacy systems with Appian requires accurately identifying supported authentication methods for system-to-system communication or user access. The question focuses on Appian' s integration capabilities, likely for both user authentication (e.g., SSO) and API authentication, as legacy system integration often involves both. Appian's documentation outlines supported methods in its Connected Systems and security configurations. Let's evaluate each option:
* A. API Keys:API Key authentication involves a static key sent in requests (e.g., via headers). Appian supports this for outbound integrations in Connected Systems (e.g., HTTP Authentication with an API key), allowing legacy systems to authenticate Appian calls. However, it's not a user authentication method for Appian's platform login-it's for system-to-system integration. While supported, it's less common for legacy system SSO or enterprise use cases compared to other options, making it a lower- priority choice here.
* B. Biometrics:Biometrics (e.g., fingerprint, facial recognition) isn't natively supported by Appian for platform authentication or integration. Appian relies on standard enterprise methods (e.g., username
/password, SSO), and biometric authentication would require external identity providers or custom clients, not Appian itself. Documentation confirms no direct biometric support, ruling this out as an Appian-supported method.
* C. SAML:Security Assertion Markup Language (SAML) is fully supported by Appian for user authentication via Single Sign-On (SSO). Appian integrates with SAML 2.0 identity providers (e.g., Okta, PingFederate), allowing users to log in using credentials from legacy systems that support SAML- based SSO. This is a key enterprise method, widely used for integrating with existing identity management systems, and explicitly listed in Appian's security configuration options-making it a top choice.
* D. CAC:Common Access Card (CAC) authentication, often used in government contexts with smart cards, isn't natively supported by Appian as a standalone method. While Appian can integrate with CAC via SAML or PKI (Public Key Infrastructure) through an identity provider, it's not a direct Appian authentication option. Documentation mentions smart card support indirectly via SSO configurations, but CAC itself isn't explicitly listed, making it less definitive than other methods.
* E. OAuth:OAuth (specifically OAuth 2.0) is supported by Appian for both outbound integrations (e.g., Authorization Code Grant, Client Credentials) and inbound API authentication (e.g., securing Appian Web APIs). For legacy system integration, Appian can use OAuth to authenticate with APIs (e.g., Google, Salesforce) or allow legacy systems to call Appian services securely. Appian's Connected System framework includes OAuth configuration, making it a versatile, standards-based method highly relevant to the client's needs.
* F. Active Directory:Active Directory (AD) integration via LDAP (Lightweight Directory Access Protocol) is supported for user authentication in Appian. It allows synchronization of users and groups from AD, enabling SSO or direct login with AD credentials. For legacy systems using AD as an identity store, this is a seamless integration method. Appian's documentation confirms LDAP/AD as a core authentication option, widely adopted in enterprise environments-making it a strong fit.
Conclusion: The three supported authentication methods are C (SAML), E (OAuth), and F (Active Directory).
These align with Appian's enterprise-grade capabilities for legacy system integration: SAML for SSO, OAuth for API security, and AD for user management. API Keys (A) are supported but less prominent for user authentication, CAC (D) is indirect, and Biometrics (B) isn't supported natively. This selection reassures the client of Appian's flexibility with common legacy authentication standards.
References:
* Appian Documentation: "Authentication for Connected Systems" (OAuth, API Keys).
* Appian Documentation: "Configuring Authentication" (SAML, LDAP/Active Directory).
* Appian Lead Developer Certification: Integration Module (Authentication Methods).

質問 # 35
As part of your implementation workflow, users need to retrieve data stored in a third-party Oracle database on an interface. You need to design a way to query this information.
How should you set up this connection and query the data?

A. Configure a Query Database node within the process model. Then, type in the connection information, as well as a SQL query to execute and return the data in process variables.
B. In the Administration Console, configure the third-party database as a "New Data Source." Then, use a queryEntity to retrieve the data.
C. Configure an expression-backed record type, calling an API to retrieve the data from the third-party database. Then, use a!queryRecordType to retrieve the data.
D. Configure a timed utility process that queries data from the third-party database daily, and stores it in the Appian business database. Then use a!queryEntity using the Appian data source to retrieve the data.

正解：B

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, designing a solution to query data from a third-party Oracle database for display on an interface requires secure, efficient, and maintainable integration. The scenario focuses on real-time retrieval for users, so the design must leverage Appian's data connectivity features. Let's evaluate each option:
* A. Configure a Query Database node within the process model. Then, type in the connection information, as well as a SQL query to execute and return the data in process variables:The Query Database node (part of the Smart Services) allows direct SQL execution against a database, but it requires manual connection details (e.g., JDBC URL, credentials), which isn't scalable or secure for Production. Appian's documentation discourages using Query Database for ongoing integrations due to maintenance overhead, security risks (e.g., hardcoding credentials), and lack of governance. This is better for one-off tasks, not real-time interface queries, making it unsuitable.
* B. Configure a timed utility process that queries data from the third-party database daily, and stores it in the Appian business database. Then use a!queryEntity using the Appian data source to retrieve the data:
This approach syncs data daily into Appian's business database (e.g., via a timer event and Query Database node), then queries it with a!queryEntity. While it works for stale data, it introduces latency (up to 24 hours) for users, which doesn't meet real-time needs on an interface. Appian's best practices recommend direct data source connections for up-to-date data, not periodic caching, unless latency is acceptable-making this inefficient here.
* C. Configure an expression-backed record type, calling an API to retrieve the data from the third-party database. Then, use a!queryRecordType to retrieve the data:Expression-backed record types use expressions (e.g., a!httpQuery()) to fetch data, but they're designed for external APIs, not direct database queries. The scenario specifies an Oracle database, not an API, so this requires building a custom REST service on the Oracle side, adding complexity and latency. Appian's documentation favors Data Sources for database queries over API calls when direct access is available, making this less optimal and over-engineered.
* D. In the Administration Console, configure the third-party database as a "New Data Source." Then, use a!queryEntity to retrieve the data:This is the best choice. In the Appian Administration Console, you can configure a JDBC Data Source for the Oracle database, providing connection details (e.g., URL, driver, credentials). This creates a secure, managed connection for querying via a!queryEntity, which is Appian's standard function for Data Store Entities. Users can then retrieve data on interfaces using expression-backed records or queries, ensuring real-time access with minimal latency. Appian's documentation recommends Data Sources for database integrations, offering scalability, security, and governance-perfect for this requirement.
Conclusion: Configuring the third-party database as a New Data Source and using a!queryEntity (D) is the recommended approach. It provides direct, real-time access to Oracle data for interface display, leveraging Appian's native data connectivity features and aligning with Lead Developer best practices for third-party database integration.
References:
* Appian Documentation: "Configuring Data Sources" (JDBC Connections and a!queryEntity).
* Appian Lead Developer Certification: Data Integration Module (Database Query Design).
* Appian Best Practices: "Retrieving External Data in Interfaces" (Data Source vs. API Approaches).

質問 # 36
You are just starting with a new team that has been working together on an application for months. They ask you to review some of their views that have been degrading in performance. The views are highly complex with hundreds of lines of SQL. What is the first step in troubleshooting the degradation?

A. Run an explain statement on the views, identify critical areas of improvement that can be remediated without business knowledge.
B. Go through the entire database structure to obtain an overview, ensure you understand the business needs, and then normalize the tables to optimize performance.
C. Go through all of the tables one by one to identify which of the grouped by, ordered by, or joined keys are currently indexed.
D. Browse through the tables, note any tables that contain a large volume of null values, and work with your team to plan for table restructure.

正解：A

解説：
Comprehensive and Detailed In-Depth Explanation:Troubleshooting performance degradation in complex SQL views within an Appian application requires a systematic approach. The views, described as having hundreds of lines of SQL, suggest potential issues with query execution, indexing, or join efficiency. As a new team member, the first step should focus on quickly identifying the root cause without overhauling the system prematurely. Appian's Performance Troubleshooting Guide and database optimization best practices provide the framework for this process.
* Option B (Run an explain statement on the views, identify critical areas of improvement that can be remediated without business knowledge):This is the recommended first step. Running an EXPLAIN statement (or equivalent, such as EXPLAIN PLAN in some databases) analyzes the query execution plan, revealing details like full table scans, missing indices, or inefficient joins. This technical analysis can identify immediate optimization opportunities (e.g., adding indices or rewriting subqueries) without requiring business input, allowing you to address low-hanging fruit quickly. Appian encourages using database tools to diagnose performance issues before involving stakeholders, making this a practical starting point as you familiarize yourself with the application.
* Option A (Go through the entire database structure to obtain an overview, ensure you understand the business needs, and then normalize the tables to optimize performance):This is too broad and time-consuming as a first step. Understanding business needs and normalizing tables are valuable but require collaboration with the team and stakeholders, delaying action. It's better suited for a later phase after initial technical analysis.
* Option C (Go through all of the tables one by one to identify which of the grouped by, ordered by, or joined keys are currently indexed):Manually checking indices is useful but inefficient without first knowing which queries are problematic. The EXPLAIN statement provides targeted insights into index usage, making it a more direct initial step than a manual table-by-table review.
* Option D (Browse through the tables, note any tables that contain a large volume of null values, and work with your team to plan for table restructure):Identifying null values and planning restructures is a long-term optimization strategy, not a first step. It requires team input and may not address the immediate performance degradation, which is better tackled with query-level diagnostics.
Starting with an EXPLAIN statement allows you to gather data-driven insights, align with Appian's performance troubleshooting methodology, and proceed with informed optimizations.
References:Appian Documentation - Performance Troubleshooting Guide, Appian Lead Developer Training
- Database Optimization, MySQL/PostgreSQL Documentation - EXPLAIN Statement.

質問 # 37
You are required to configure a connection so that Jira can inform Appian when specific tickets change (using a webhook). Which three required steps will allow you to connect both systems?

A. Create an integration object from Appian to Jira to periodically check the ticket status.
B. Configure the connection in Jira specifying the URL and credentials.
C. Create a new API Key and associate a service account.
D. Give the service account system administrator privileges.
E. Create a Web API object and set up the correct security.

正解：B、C、E

質問 # 38
Your client's customer management application is finally released to Production. After a few weeks of small enhancements and patches, the client is ready to build their next application. The new applicationwill leverage customer information from the first application to allow the client to launch targeted campaigns for select customers in order to increase sales. As part of the first application, your team had built a section to display key customer information such as their name, address, phone number, how long they have been a customer, etc. A similar section will be needed on the campaign record you are building. One of your developers shows you the new object they are working on for the new application and asks you to review it as they are running into a few issues. What feedback should you give?

A. Provide guidance to the developer on how to address the issues so that they can proceed with their work.
B. Point the developer to the relevant areas in the documentation or Appian Community where they can find more information on the issues they are running into.
C. Create a duplicate version of that section designed for the campaign record.
D. Ask the developer to convert the original customer section into a shared object so it can be used by the new application.

正解：D

解説：
Comprehensive and Detailed In-Depth Explanation:The scenario involves reusing a customer information section from an existing application in a new application for campaign management, with the developer encountering issues. Appian's best practices emphasize reusability, efficiency, and maintainability, especially when leveraging existing components across applications.
* Option B (Ask the developer to convert the original customer section into a shared object so it can be used by the new application):This is the recommended approach. Converting the original section into a shared object (e.g., a reusable interface component) allows it to be accessed across applications without duplication. Appian's Design Guide highlights the use of shared components to promote consistency, reduce redundancy, and simplify maintenance. Since the new application requires similar customer data (name, address, etc.), reusing the existing section-after ensuring it is modular and adaptable-addresses the developer's issues while aligning with the client's goal of leveraging prior work. The developer can then adjust the shared object (e.g., via parameters) to fit the campaign context, resolving their issues collaboratively.
* Option A (Provide guidance to the developer on how to address the issues so that they can proceed with their work):While providing guidance is valuable, it doesn't address the root opportunity to reuse existing code. This option focuses on fixing the new object in isolation, potentially leading to duplicated effort if the original section could be reused instead.
* Option C (Point the developer to the relevant areas in the documentation or Appian Community where they can find more information on the issues they are running into):This is a passive approach and delays resolution. As a Lead Developer, offering direct support ora strategic solution (like reusing components) is more effective than redirecting the developer to external resources without context.
* Option D (Create a duplicate version of that section designed for the campaign record):
Duplication violates Appian's principle of DRY (Don't Repeat Yourself) and increases maintenance overhead. Any future updates to customer data display logic would need to be applied to multiple objects, risking inconsistencies.
Given the need to leverage existing customer information and the developer's issues, converting the section to a shared object is the most efficient and scalable solution.
References:Appian Design Guide - Reusability and Shared Components, Appian Lead Developer Training - Application Design and Maintenance.

質問 # 39
Your team has deployed an application to Production with an underperforming view. Unexpectedly, the production data is ten times that of what was tested, and you must remediate the issue. What is the best option you can take to mitigate their performance concerns?

A. Create a materialized view or table.
B. Introduce a data management policy to reduce the volume of data.
C. Create a table which is loaded every hour with the latest data.
D. Bypass Appian's query rule by calling the database directly with a SQL statement.

正解：A

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, addressing performance issues in production requires balancing Appian's best practices, scalability, and maintainability. The scenario involves an underperforming view due to a significant increase in data volume (ten times the tested amount), necessitating a solution that optimizes performance while adhering to Appian's architecture. Let's evaluate each option:
* A. Bypass Appian's query rule by calling the database directly with a SQL statement:This approach involves circumventing Appian's query rules (e.g., a!queryEntity) and directly executing SQL against the database. While this might offer a quick performance boost by avoiding Appian's abstraction layer, it violates Appian's core design principles. Appian Lead Developer documentation explicitly discourages direct database calls, as they bypass security (e.g., Appian's row-level security), auditing, and portability features. This introduces maintenance risks, dependencies on database-specific logic, and potential production instability-making it an unsustainable and non-recommended solution.
* B. Create a table which is loaded every hour with the latest data:This suggests implementing a staging table updated hourly (e.g., via an Appian process model or ETL process). While this could reduce query load by pre-aggregating data, it introduces latency (data is only fresh hourly), which may not meet real- time requirements typical in Appian applications (e.g., a customer-facing view). Additionally, maintaining an hourly refresh process adds complexity and overhead (e.g., scheduling, monitoring).
Appian's documentation favors more efficient, real-time solutions over periodic refreshes unless explicitly required, making this less optimal for immediate performance remediation.
* C. Create a materialized view or table:This is the best choice. A materialized view (or table, depending on the database) pre-computes and stores query results, significantly improving retrieval performance for large datasets. In Appian, you can integrate a materialized view with a Data Store Entity, allowing a!
queryEntity to fetch data efficiently without changing application logic. Appian Lead Developer training emphasizes leveraging database optimizations like materialized views to handle large data volumes, as they reduce query execution time while keeping data consistent with the source (via periodic or triggered refreshes, depending on the database). This aligns with Appian's performance optimization guidelines and addresses the tenfold data increase effectively.
* D. Introduce a data management policy to reduce the volume of data:This involves archiving or purging data to shrink the dataset (e.g., moving old records to an archive table). While a long-term data management policy is a good practice (and supported by Appian's Data Fabric principles), it doesn't immediately remediate the performance issue. Reducing data volume requires business approval, policy design, and implementation-delaying resolution. Appian documentation recommends combining such strategies with technical fixes (like C), but as a standalone solution, it's insufficient for urgent production concerns.
Conclusion: Creating a materialized view or table (C) is the best option. It directly mitigates performance by optimizing data retrieval, integrates seamlessly with Appian's Data Store, and scales for large datasets-all while adhering to Appian's recommended practices. The view can be refreshed as needed (e.g., via database triggers or schedules), balancing performance and data freshness. This approach requires collaboration with a DBA to implement but ensures a robust, Appian-supported solution.
References:
* Appian Documentation: "Performance Best Practices" (Optimizing Data Queries with Materialized Views).
* Appian Lead Developer Certification: Application Performance Module (Database Optimization Techniques).
* Appian Best Practices: "Working with Large Data Volumes in Appian" (Data Store and Query Performance).

質問 # 40
You are designing a process that is anticipated to be executed multiple times a day. This process retrieves data from an external system and then calls various utility processes as needed. The main process will not use the results of the utility processes, and there are no user forms anywhere.
Which design choice should be used to start the utility processes and minimize the load on the execution engines?

A. Use the Start Process Smart Service to start the utility processes.
B. Start the utility processes via a subprocess synchronously.
C. Use Process Messaging to start the utility process.
D. Start the utility processes via a subprocess asynchronously.

正解：D

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, designing a process that executes frequently (multiple times a day) and calls utility processes without using their results requires optimizing performance and minimizing load on Appian's execution engines. The absence of user forms indicates a backend process, so user experience isn't a concern-only engine efficiency matters. Let's evaluate each option:
* A. Use the Start Process Smart Service to start the utility processes:The Start Process Smart Service launches a new process instance independently, creating a separate process in the Work Queue. While functional, it increases engine load because each utility process runs as a distinct instance, consuming engine resources and potentially clogging the Java Work Queue, especially with frequent executions.
Appian's performance guidelines discourage unnecessary separate process instances for utility tasks, favoring integrated subprocesses, making this less optimal.
* B. Start the utility processes via a subprocess synchronously:Synchronous subprocesses (e.g., a!
startProcess with isAsync: false) execute within the main process flow, blocking until completion. For utility processes not used by the main process, this creates unnecessary delays, increasing execution time and engine load. With frequent daily executions, synchronous subprocesses could strain engines, especially if utility processes are slow or numerous. Appian's documentation recommends asynchronous execution for non-dependent, non-blocking tasks, ruling this out.
* C. Use Process Messaging to start the utility process:Process Messaging (e.g., sendMessage() in Appian) is used for inter-process communication, not for starting processes. It's designed to pass data between running processes, not initiate new ones. Attempting to use it for starting utility processes would require additional setup (e.g., a listening process) and isn't a standard or efficient method.
Appian's messaging features are for coordination, not process initiation, making this inappropriate.
* D. Start the utility processes via a subprocess asynchronously:This is the best choice. Asynchronous subprocesses (e.g., a!startProcess with isAsync: true) execute independently of the main process, offloading work to the engine without blocking or delaying the parent process. Since the main process doesn't use the utility process results and there are no user forms, asynchronous execution minimizes engine load by distributing tasks across time, reducing Work Queue pressure during frequent executions. Appian's performance best practices recommend asynchronous subprocesses for non- dependent, utility tasks to optimize engine utilization, making this ideal for minimizing load.
Conclusion: Starting the utility processes via a subprocess asynchronously (D) minimizes engine load by allowing independent execution without blocking the main process, aligning with Appian's performance optimization strategies for frequent, backend processes.
References:
* Appian Documentation: "Process Model Performance" (Synchronous vs. Asynchronous Subprocesses).
* Appian Lead Developer Certification: Process Design Module (Optimizing Engine Load).
* Appian Best Practices: "Designing Efficient Utility Processes" (Asynchronous Execution).

質問 # 41
You are selling up a new cloud environment. The customer already has a system of record for Its employees and doesn't want to re-create them in Appian. so you are going to Implement LDAP authentication.
What are the next steps to configure LDAP authentication?
To answer, move the appropriate steps from the Option list to the Answer List area, and arrange them in the correct order. You may or may not use all the steps.

正解：

解説：

Explanation:
* Navigate to the Admin console > Authentication > LDAP. This is the first step, as it allows you to access the settings and options for LDAP authentication in Appian.
* Work with the customer LDAP point of contact to obtain the LDAP authentication xsd. Import the xsd file in the Admin console. This is the second step, as it allows you to define the schema and structure of the LDAP data that will be used for authentication in Appian. You will need to work with the customer LDAP point of contact to obtain the xsd file that matches their LDAP server configuration and data model. You will then need to import the xsd file in the Admin console using the Import Schema button.
* Enable LDAP and enter the LDAP parameters, such as the URL of the LDAP server and plaintext credentials. This is the third step, as it allows you to enable and configure the LDAP authentication in Appian. You will need to check the Enable LDAP checkbox and enter the required parameters, such as the URL of the LDAP server, the plaintext credentials for connecting to the LDAP server, and the base DN for searching for users in the LDAP server.
* Test the LDAP integration and see if it succeeds. This is the fourth and final step, as it allows you to verify and validate that the LDAP authentication is working properly in Appian. You will need to use the Test Connection button to test if Appian can connect to the LDAP server successfully.
You will also need to use the Test User Lookup button to test if Appian can find and authenticate a user from the LDAP server using their username and password.
Configuring LDAP authentication in Appian Cloud allows the platform to leverage an existing employee system of record (e.g., Active Directory) for user authentication, avoiding manual user creation. Theprocess involves a series of steps within the Appian Administration Console, guided by Appian's Security and Authentication documentation. The steps must be executed in a logical order to ensure proper setup and validation.
* Navigate to the Admin Console > Authentication > LDAP:The first step is to access the LDAP configuration section in the Appian Administration Console. This is the entry point for enabling and configuring LDAP authentication, where administrators can define the integration settings. Appian requires this initial navigation to begin the setup process.
* Work with the customer LDAP point-of-contact to obtain the LDAP authentication xsd. Import the xsd file in the Admin Console:The next step involves gathering the LDAP schema definition (xsd file) from the customer's LDAP system (e.g., via their point-of-contact). This file defines the structure of the LDAP directory (e.g., user attributes). Importing it into the Admin Console allows Appian to map these attributes to its user model, a critical step before enabling authentication, as outlined in Appian's LDAP Integration Guide.
* Enable LDAP and enter the appropriate LDAP parameters, such as the URL of the LDAP server and plaintext credentials:After importing the schema, enable LDAP and configure the connection details. This includes specifying the LDAP server URL (e.g., ldap://ldap.example.com) and plaintext credentials (or a secure alternative like LDAPS with certificates). These parameters establish the connection to the customer's LDAP system, a prerequisite for testing, as per Appian's security best practices.
* Test the LDAP integration and save if it succeeds:The final step is to test the configuration to ensure Appian can authenticate against the LDAP server. The Admin Console provides a test option to verify connectivity and user synchronization. If successful, saving the configuration applies the settings, completing the setup. Appian recommends this validation step to avoid misconfigurations, aligning with the iterative testing approach in the documentation.
Unused Option:
* Enter two parameters: the URL of the LDAP server and plaintext credentials:This step is redundant and not used. The equivalent action is covered under "Enable LDAP and enter the appropriate LDAP parameters," which is more comprehensive and includes enablingthe feature.
Including both would be duplicative, and Appian's interface consolidates parameter entry with enabling.
Ordering Rationale:
* The sequence follows a logical workflow: navigation to the configuration area, schema import for structure, parameter setup for connectivity, and testing/saving for validation. This aligns with Appian's step-by-step LDAP setup process, ensuring each step builds on the previous one without requiring backtracking.
* The unused option reflects the question's allowance for not using all steps, indicating flexibility in the process.
References:Appian Documentation - Security and Authentication Guide, Appian Administration Console - LDAP Configuration, Appian Lead Developer Training - Integration Setup.

質問 # 42
You are tasked to build a large-scale acquisition application for a prominent customer. The acquisition process tracks the time it takes to fulfill a purchase request with an award.
The customer has structured the contract so that there are multiple application development teams.
How should you design for multiple processes and forms, while minimizing repeated code?

A. Create a Scrum of Scrums sprint meeting for the team leads.
B. Create duplicate processes and forms as needed.
C. Create a common objects application.
D. Create a Center of Excellence (CoE).

正解：C

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, designing a large-scale acquisition application with multiple development teams requires a strategy to manage processes, forms, and code reuse effectively. The goal is to minimize repeated code (e.g., duplicate interfaces, process models) while ensuring scalability and maintainability across teams. Let's evaluate each option:
* A. Create a Center of Excellence (CoE):A Center of Excellence is an organizational structure or team focused on standardizing practices, training, and governance across projects. While beneficial for long- term consistency, it doesn't directly address the technical design of minimizing repeated code for processes and forms. It's a strategic initiative, not a design solution, and doesn't solve the immediate need for code reuse. Appian's documentation mentions CoEs for governance but not as a primary design approach, making this less relevant here.
* B. Create a common objects application:This is the best recommendation. In Appian, a "common objects application" (or shared application) is used to store reusable components like expression rules, interfaces, process models, constants, and data types (e.g., CDTs). For a large-scale acquisition application with multiple teams, centralizing shared objects (e.g., rule!CommonForm, pm!
CommonProcess) ensures consistency, reduces duplication, and simplifies maintenance. Teams can reference these objects in their applications, adhering to Appian's design best practices for scalability.
This approach minimizes repeated code while allowing team-specific customizations, aligning with Lead Developer standards for large projects.
* C. Create a Scrum of Scrums sprint meeting for the team leads:A Scrum of Scrums meeting is a coordination mechanism for Agile teams, focusing on aligning sprint goals and resolving cross-team dependencies. While useful for collaboration, it doesn't address the technical design of minimizing repeated code-it's a process, not a solution for codereuse. Appian's Agile methodologies support such meetings, but they don't directly reduce duplication in processes and forms, making this less applicable.
* D. Create duplicate processes and forms as needed:Duplicating processes and forms (e.g., copying interface!PurchaseForm for each team) leads to redundancy, increased maintenance effort, and potential inconsistencies (e.g., divergent logic). This contradicts the goal of minimizing repeated code and violates Appian's design principles for reusability and efficiency. Appian's documentation strongly discourages duplication, favoring shared objects instead, making this the least effective option.
Conclusion: Creating a common objects application (B) is the recommended design. It centralizes reusable processes, forms, and other components, minimizing code duplication across teams while ensuring consistency and scalability for the large-scale acquisition application. This leverages Appian's application architecture for shared resources, aligning with Lead Developer best practices for multi-team projects.
References:
* Appian Documentation: "Designing Large-Scale Applications" (Common Application for Reusable Objects).
* Appian Lead Developer Certification: Application Design Module (Minimizing Code Duplication).
* Appian Best Practices: "Managing Multi-Team Development" (Shared Objects Strategy).
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]

質問 # 43
While working on an application, you have identified oddities and breaks in some of your components. How can you guarantee that this mistake does not happen again in the future?

A. Ensure that the application administrator group only has designers from that application's team.
B. Design and communicate a best practice that dictates designers only work within the confines of their own application.
C. Create a best practice that enforces a peer review of the deletion of any components within the application.
D. Provide Appian developers with the "Designer" permissions role within Appian. Ensure that they have only basic user rights and assign them the permissions to administer their application.

正解：C

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, preventing recurring
"oddities and breaks" in application components requires addressing root causes-likely tied to human error, lack of oversight, or uncontrolled changes-while leveraging Appian's governance and collaboration features.
The question implies a past mistake (e.g., accidental deletions or modifications) and seeks a proactive, sustainable solution. Let's evaluate each option based on Appian's official documentation and best practices:
* A. Design and communicate a best practice that dictates designers only work within the confines of their own application:This suggests restricting designers to their assigned applications via a policy.
While Appian supports application-level security (e.g., Designer role scoped to specific applications), this approach relies on voluntary compliance rather than enforcement. It doesn't directly address
"oddities and breaks"-e.g., a designer could still mistakenly alter components within their own application. Appian's documentation emphasizes technical controls and process rigor over broad guidelines, making this insufficient as a guarantee.
* B. Ensure that the application administrator group only has designers from that application's team:This involves configuring security so only team-specific designers have Administrator rights to the application (via Appian's Security settings). While this limits external interference, it doesn't prevent internal mistakes (e.g., a team designer deleting a critical component). Appian's security model already restricts access by default, and the issue isn't about unauthorized access but rather component integrity.
This step is a hygiene factor, not a direct solution to the problem, and fails to "guarantee" prevention.
* C. Create a best practice that enforces a peer review of the deletion of any components within the application:This is the best choice. A peer review process for deletions (e.g., process models, interfaces, or records) introduces a checkpoint to catch errors before they impact the application. In Appian, deletions are permanent and can cascade (e.g., breaking dependencies), aligning with the "oddities and breaks" described. While Appian doesn't natively enforce peer reviews, this can be implemented via team workflows-e.g., using Appian's collaboration tools (like Comments or Tasks) or integrating with version control practices during deployment. Appian Lead Developer training emphasizes change management and peer validation to maintain application stability, making this a robust, preventive measure that directly addresses the root cause.
* D. Provide Appian developers with the "Designer" permissions role within Appian. Ensure that they have only basic user rights and assign them the permissions to administer their application:This option is confusingly worded but seems to suggest granting Designer system role permissions (a high-level privilege) while limiting developers to Viewer rights system-wide, withAdministrator rights only for their application. In Appian, the "Designer" system role grants broad platform access (e.g., creating applications), which contradicts "basic user rights" (Viewer role). Regardless, adjusting permissions doesn't prevent mistakes-it only controls who can make them. The issue isn't about access but about error prevention, so this option misses the mark and is impractical due to its contradictory setup.
Conclusion: Creating a best practice that enforces a peer review of the deletion of any components (C) is the strongest solution. It directly mitigates the risk of "oddities and breaks" by adding oversight to destructive actions, leveraging team collaboration, and aligning with Appian's recommended governance practices.
Implementation could involve documenting the process, training the team, and using Appian's monitoring tools (e.g., Application Properties history) to track changes-ensuring mistakes are caught before deployment.
This provides the closest guarantee to preventing recurrence.
References:
* Appian Documentation: "Application Security and Governance" (Change Management Best Practices).
* Appian Lead Developer Certification: Application Design Module (Preventing Errors through Process).
* Appian Best Practices: "Team Collaboration in Appian Development" (Peer Review Recommendations).

質問 # 44
You are the project lead for an Appian project with a supportive product owner and complex business requirements involving a customer management system. Each week, you notice the product owner becoming more irritated and not devoting as much time to the project, resulting in tickets becoming delayed due to a lack of involvement. Which two types of meetings should you schedule to address this issue?

A. A risk management meeting with your program manager to escalate the delayed tickets.
B. A meeting with the sponsor to discuss the product owner's performance and request a replacement.
C. A sprint retrospective with the product owner and development team to discuss team performance.
D. An additional daily stand-up meeting to ensure you have more of the product owner's time.

正解：A、C

解説：
Comprehensive and Detailed In-Depth Explanation:As an Appian Lead Developer, managing stakeholder engagement and ensuring smooth project progress are critical responsibilities. The scenario describes a product owner whose decreasing involvement is causing delays, which requires a proactive and collaborative approach rather than an immediate escalation to replacement. Let's analyze each option:
* A. An additional daily stand-up meeting: While daily stand-ups are a core Agile practice to align the team, adding another one specifically to secure the product owner's time is inefficient. Appian's Agile methodology (aligned with Scrum) emphasizes that stand-ups are for the development team to coordinate, not to force stakeholder availability. The product owner's irritation might increase with additional meetings, making this less effective.
* B. A risk management meeting with your program manager: This is a correct choice. Appian Lead Developer documentation highlights the importance of risk management in complex projects (e.g., customer management systems). Delays due to lack of product owner involvement constitute a project risk. Escalating this to the program manager ensures visibility and allows for strategic mitigation, such as resource reallocation or additional support, without directly confronting the product owner in a way that could damage the relationship. This aligns with Appian's project governance best practices.
* C. A sprint retrospective with the product owner and development team: This is also a correct choice.
The sprint retrospective, as per Appian's Agile guidelines, is a key ceremony to reflect on what's working and what isn't. Including the product owner fosters collaboration and provides a safe space to address their reduced involvement and its impact on ticket delays. It encourages team accountability and aligns with Appian's focus on continuous improvement in Agile development.
* D. A meeting with the sponsor to discuss the product owner's performance and request a replacement:
This is premature and not recommended as a first step. Appian's Lead Developer training emphasizes maintaining strong stakeholder relationships and resolving issues collaboratively before escalating to drastic measures like replacement. This option risksalienating the product owner and disrupting the project further, which contradicts Appian's stakeholder management principles.
Conclusion: The best approach combines B (risk management meeting) to address the immediate risk of delays with a higher-level escalation and C (sprint retrospective) to collaboratively resolve the product owner' s engagement issues. These align with Appian's Agile and leadership strategies for Lead Developers.
References:
* Appian Lead Developer Certification: Agile Project Management Module (Risk Management and Stakeholder Engagement).
* Appian Documentation: "Best Practices for Agile Development in Appian" (Sprint Retrospectives and Team Collaboration).

質問 # 45
You have created a Web API in Appian with the following URL to call it: https://exampleappiancloud.com
/suite/webapi/user_management/users?username=john.smith. Which is the correct syntax for referring to the username parameter?

A. httpRequest.formData.username
B. httpRequest.queryParameters.users.username
C. httpRequest.users.username
D. httpRequest.queryParameters.username

正解：D

解説：
Comprehensive and Detailed In-Depth Explanation:In Appian, when creating a Web API, parameters passed in the URL (e.g., query parameters) are accessed within the Web API expression using the httpRequest object. The URL https://exampleappiancloud.com/suite/webapi/user_management/users?username=john.
smith includes a query parameter username with the value john.smith. Appian's Web API documentation specifies how to handle such parameters in the expression rule associated with the Web API.
* Option D (httpRequest.queryParameters.username):This is the correct syntax. The httpRequest.
queryParameters object contains all query parameters from the URL. Since username is a single query parameter, you access it directly as httpRequest.queryParameters.username. This returns the value john.
smith as a text string, which can then be used in the Web API logic (e.g., to query a user record).
Appian's expression language treats query parameters as key-value pairs under queryParameters, making this the standard approach.
* Option A (httpRequest.queryParameters.users.username):This is incorrect. The users part suggests a nested structure (e.g., users as a parameter containing a username subfield), which does not match the URL. The URL only defines username as a top-level query parameter, not a nested object.
* Option B (httpRequest.users.username):This is invalid. The httpRequest object does not have a direct users property. Query parameters are accessed via queryParameters, and there's no indication of a users object in the URL or Appian's Web API model.
* Option C (httpRequest.formData.username):This is incorrect. The httpRequest.formData object is used for parameters passed in the body of a POST or PUT request (e.g., form submissions), not for query parameters in a GET request URL. Since the username is part of the query string (?
username=john.smith), formData does not apply.
The correct syntax leverages Appian's standard handling of query parameters, ensuring the Web API can process the username value effectively.
References:Appian Documentation - Web API Development, Appian Expression Language Reference -
httpRequest Object.

質問 # 46
You are deciding the appropriate process model data management strategy.
For each requirement. match the appropriate strategies to implement. Each strategy will be used once.
Note: To change your responses, you may deselect your response by clicking the blank space at the top of the selection list.

正解：

解説：

Explanation:
* 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
"remainavailable 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.
References:Appian Documentation - Process Management Guide, Appian Administration Console - Process Model Settings, Appian Lead Developer Training - Data Management Strategies.