AD0-E902 Adobe Workfront Fusion Professional Questions and Answers

Understanding the Requirement :

The field data from a third-party system needs to be transformed into one of three possible choices.

This transformation implies conditional logic, where the output depends on the value of the input field.

Why Option A ("Switch") is Correct :

The Switch function evaluates a given input against multiple cases and outputs a corresponding value based on the matched condition.

For example:

switch(field, "value1", "choice1", "value2", "choice2", "defaultChoice")

If field equals "value1", the output is "choice1".

If field equals "value2", the output is "choice2".

If no conditions match, the output is "defaultChoice".

This functionality perfectly fits the requirement to transform the input into one of three possible choices.

Why the Other Options are Incorrect :

Option B ("Slice") :

The slice function is used for extracting a portion of a string or array but does not support conditional transformations.

Option C ("Split") :

The split function divides a string into an array based on a specified delimiter. It is not designed for conditional logic or value mapping.

How This Solves the Problem :

The Switch function allows flexible and dynamic transformations, ensuring the field data is mapped to the correct choice based on its value.

References and Supporting Documentation :

Adobe Workfront Fusion Functions Documentation

Workfront Community: Using the Switch Function for Conditional Logic

Understanding the Issue :

The scenario is making too many API requests, causing the third-party API to return a 429 "Too Many Requests" error, which indicates that the rate limit has been exceeded.

The solution needs to reduce unnecessary or redundant API requests to prevent hitting the API limits.

Why Option B is Correct :

Avoid Redundant Requests :

Placing Search and GET modules earlier in the scenario ensures that all required data is retrieved in one batch or in fewer requests, rather than repeatedly querying the same record later in the scenario.

This technique reduces the overall number of API requests sent to the third-party system.

Efficient Data Flow :

By structuring the scenario to retrieve all necessary data at the beginning, subsequent modules can reuse the retrieved data instead of making additional API calls.

Why the Other Options are Incorrect :

Option A ("Using a Search module and then a Read Record module") :

This approach can increase API requests, as the Search module retrieves record IDs, and the Read Record module makes separate API requests for each record. This often results in more requests than necessary.

Option C ("Adding a Retry error handling directive") :

Adding a Retry directive does not reduce the number of requests. Instead, it retries failed requests, which could worsen the problem by increasing API traffic.

Best Practices to Reduce API Requests :

Consolidate data retrieval into a single module or a smaller number of requests.

Use caching or intermediate storage (like Fusion Data Stores) to avoid re-fetching the same data.

Limit the scope of Search modules by using filters or pagination to process smaller, relevant data sets.

References and Supporting Documentation :

Adobe Workfront Fusion Best Practices: Managing API Rate Limits

Workfront Community: Error 429 Solutions

A. Expected Outcome of Test

A test case must clearly state what the expected outcome is, providing a standard against which the results can be measured.

This ensures testers can validate whether the scenario behaves as intended.

C. Clear Procedure for Completing the Test

A well-defined procedure outlines the exact steps required to execute the test, ensuring consistent and repeatable testing.

This reduces ambiguity and helps identify whether errors are due to the scenario configuration or improper test execution.

Why Not Other Options?

B. Name of Test Owner : While helpful for accountability, the name of the test owner is not a required component of the test case itself.

D. Source Code Being Tested : Fusion scenarios do not typically involve source code. Instead, the focus is on workflow execution and configuration, making this element irrelevant.

References :

Workfront Training Materials: Test Case Design Best Practices

Adobe Workfront Fusion Documentation: Testing and Debugging Scenarios

Step by Step Comprehensive Detailed Explanation :

Understanding the Scenario :

The diagram shows two routes, each leading to an aggregator module (Aggregator 1 and Aggregator 2).

The bundle inspector indicates different output counts for the two aggregators: Aggregator 1 displays 1, and Aggregator 2 displays 10.

Option Analysis :

A. Aggregator 1’s route is set to process the 1st bundle only, and Aggregator 2's route is set to process all bundles :

Incorrect. Aggregators process data from their input modules based on their configuration. While filters or limits might be applied earlier in the flow, the scenario does not suggest that the aggregator's configuration explicitly limits bundles in this way.

B. The source module for the aggregators are different :

Correct. The two aggregators receive input from different modules. For example, Aggregator 1 might aggregate bundles from "Projects," which outputs a single bundle, while Aggregator 2 aggregates bundles from "Issues," which outputs 10 bundles. This explains the differing numbers in the bundle inspector.

C. Aggregator 2 displays a 10 in the bundle inspector because it is set to repeat 10 times :

Incorrect. Aggregators do not "repeat" a specific number of times. Instead, they process the input bundles passed to them and output a result based on the aggregation logic.

D. The scenario's router is set to only allow projects through the route to Aggregator 1 and only allows tasks through the route to Aggregator 2 :

Incorrect. While the router might direct specific bundles (e.g., "Projects" to Aggregator 1 and "Issues" to Aggregator 2), the difference in bundle counts is determined by the source modules, not by the router's configuration alone.

Why Source Modules Determine Bundle Counts :

Each aggregator processes data from a source module. If the source module outputs different numbers of bundles, the aggregators will show different bundle counts.

In this example, "Projects" might output only 1 bundle (e.g., 1 project), while "Issues" outputs 10 bundles (e.g., 10 issues).

How to Verify :

Inspect the source modules feeding into each aggregator. Check the number of bundles they produce during the scenario run.

Confirm that the aggregators are aggregating based on their respective inputs.

References : This explanation aligns with Workfront Fusion's handling of bundles and aggregation logic. Differences in bundle counts at the aggregator level are typically due to differences in the source module outputs, as shown in the scenario.

Understanding the Diagram :

The image depicts a Workfront Fusion scenario using Routers to split and manage multiple execution paths.

Fusion executes modules in a left-to-right and top-to-bottom sequence along each path. Routers direct the flow to downstream modules.

Determining the Execution Sequence :

Path 1 :

The first path begins with Google Drive . The Router branches out, directing execution sequentially to other modules.

Path 2 :

The second path starts with Email and continues downwards through the remaining modules.

Order Within Branches :

After passing through a Router, each branch completes its sequence of modules before moving to the next Router.

Why Option D is Correct :

Execution begins from the leftmost module ( Google Drive ) and flows rightward. The sequence is as follows:

Google Drive

Email

Data Store

Workfront

Salesforce

This matches the visual layout and Fusion's execution rules for scenarios with Routers.

Why the Other Options are Incorrect :

Option A ("Google Drive > Email > Workfront > Data Store > Salesforce") :

Incorrect because Workfront does not precede Data Store in the execution order.

Option B ("Email > Workfront > Data Store > Salesforce > Google Drive") :

Incorrect because execution begins with Google Drive , not Email.

Option C ("Email > Data Store > Workfront > Salesforce") :

Incorrect because it excludes Google Drive as the starting point and places modules out of sequence.

Execution Rules in Workfront Fusion :

Fusion executes modules in the order they appear visually, starting from left to right and top to bottom within each branch.

Routers split the execution into separate branches, which are completed sequentially.

References and Supporting Documentation :

Adobe Workfront Fusion: Execution Flow Rules

Workfront Community: Understanding Router and Module Execution

The correct execution sequence is Google Drive > Email > Data Store > Workfront > Salesforce, ensuring all paths are processed as per the scenario's layout.

Understanding the Requirement :

The project name in Workfront must include:

Purchase Order Number (PO#).

Name of the product.

PO Fulfillment Date (formatted as YY/MM/DD).

If a discount is provided, append the discount percentage and the approver's last name in the format: 15% Discount - UserLast.

Example Output:

sql

Copy

2837 - Compendium-Premium Running Shoes - 21/02/16 - 15% Discount - UserLast

Why Option A is Correct :

The expression in Option A achieves the desired result step-by-step:

3.PO#: Includes the PO number.

3.Name: Appends the name of the product.

formatDate(3.PO Fulfillment Date, YY/MM/DD): Formats the PO Fulfillment Date in the desired YY/MM/DD format.

if(3.Discount Provided? = "Yes"; "- " + 3.Discount % + " Discount - " + 3.Approver Last Name):

Uses the if function to check if a discount was provided.

If "Yes," it appends the discount percentage (3.Discount %) and approver's last name (3.Approver Last Name) with the required format.

Why the Other Options are Incorrect :

Option B :

The expression is incorrect because it places if(3.Discount Provided?...) directly after PO Fulfillment Date without using formatDate for date formatting. This results in an unformatted date.

Option C :

Uses parseDate instead of formatDate, which is incorrect in this context. parseDate is used to interpret strings as dates, not to format dates for output.

Option D :

The expression does not include any conditional logic for checking if a discount is provided. It simply appends Discount - Approver Last Name regardless of whether a discount was given.

Steps to Use the Expression in Workfront Fusion :

Place the expression in the module that defines the project title in Workfront.

Map the fields (PO#, Name, PO Fulfillment Date, etc.) to the respective columns from the CSV data.

Test the scenario to ensure the output matches the desired format.

Final Expression (Option A) :

3.PO# + " - " + 3.Name + " - " + formatDate(3.PO Fulfillment Date; YY/MM/DD) + if(3.Discount Provided? = "Yes"; " - " + 3.Discount % + " Discount - " + 3.Approver Last Name)

References and Supporting Documentation :

Adobe Workfront Fusion Functions Documentation

Workfront Community: Handling Conditional Logic and Date Formatting

Workfront's training on scenario testing emphasizes the importance of a well-structured test plan to ensure scenario reliability and accuracy. The three essential elements include:

B. Description of Expected Behavior :

This provides clarity on what the scenario is supposed to achieve when executed successfully.

It serves as a benchmark for evaluating the outcome of test executions.

C. Specific Event/Trigger per Scenario :

Identifying and testing specific triggers ensures that the scenario starts under the correct conditions.

This is crucial for verifying the proper configuration of the scenario’s start point.

D. Description of Testing Steps :

Outlining step-by-step instructions for the testing process ensures that all aspects of the scenario are tested systematically.

It helps identify potential bottlenecks or areas for improvement in the scenario’s configuration.

Why Not Other Options?

A. Roadmap requirements : This pertains to project planning and is not directly relevant to scenario testing.

E. Executive sponsor expectations : While valuable for overall project alignment, it is not an essential component of a technical test plan.

References :

Workfront Training Materials: Best Practices for Scenario Testing

Experience League Documentation: How to Design and Execute a Test Plan for Workfront Fusion Scenarios

Step by Step Comprehensive Detailed Explanation :

Understanding the Requirement :

The user needs to archive the last five versions of a scenario for one year.

Archiving ensures there is a record of previous versions in case rollback or review is needed.

Option Analysis :

A. Save the scenario frequently :

Incorrect. While frequent saving ensures changes are not lost, it does not provide an archival mechanism for version history.

B. Download the scenario blueprints :

Correct. Downloading blueprints of the scenario allows the user to store version snapshots externally. Blueprints include the complete design and settings of the scenario, making them ideal for archival purposes.

C. Clone the scenario anytime the design changes :

Incorrect. Cloning creates duplicates of the scenario but does not inherently manage or track version history for archival purposes.

D. Find previous versions using the History tab :

Incorrect. The History tab only shows recent edits and logs but does not provide a long-term archiving solution.

Why Downloading Blueprints is Best :

External Storage : Blueprints can be downloaded and stored securely for long-term use.

Restoration : A saved blueprint can be re-imported into Fusion to restore a scenario exactly as it was.

Version Control : Allows the user to manually manage and organize multiple scenario versions over time.

Implementation Steps :

Go to the scenario in Workfront Fusion.

Use the Download Blueprint option to save a copy of the scenario.

Label and organize the blueprints by version and date for easy retrieval later.

Understanding the Scenario :

The scenario includes two modules:

Workfront Search Module : Fetches data (likely project details).

Tools Module : Manipulates and sets multiple variables.

What the Images Show :

Workfront Search Module (First Module) :

The output indicates 29 bundles of project data were retrieved.

Each bundle contains fields such as ID , name , and plannedCompletionDate .

Tools Module (Second Module) :

The data from the Workfront module is processed to set variables like Project Name and Project Due Date .

Output includes transformed values, such as appending the approver’s name ("Joan Harris") to the project name and updating the project due date.

Why Option C is Correct :

Delivery of 29 Bundles : The Workfront module retrieved 29 project bundles and passed them to the Tools module.

Data Manipulation in Tools Module : The second module modified the data, such as appending "Joan Harris" to the project name and updating the due date to a different value. This is evident from the changes in the output of the Tools module compared to the input from the Workfront module.

Why the Other Options are Incorrect :

Option A :

Incorrect because the Workfront module retrieved 29 bundles, not just 1 bundle. Additionally, the project name and planned completion date were manipulated in the second module, not the first.

Option B :

Incorrect because the retrieved data pertains to projects, not tasks.

Option D :

Incorrect because the input and output fields in the Tools module are not identical. The data was clearly manipulated within the Tools module.

How This Scenario Operates :

The Workfront module fetches raw data, which is then processed in the Tools module. The processed variables (e.g., modified project names and due dates) are prepared for further use in subsequent scenario steps.

References and Supporting Documentation :

Adobe Workfront Fusion Documentation: Bundle Inspector

Workfront Community: Using Tools Module for Data Manipulation

The correct interpretation is that the first module delivered 29 bundles to the second module, where data manipulations occurred to modify the project name and planned completion date.

Understanding the Requirement :

If a third-party system does not have a dedicated app connector in Workfront Fusion, users can still build an integration using Universal Connectors.

Universal Connectors in Fusion allow users to configure custom API calls, enabling communication with systems that lack pre-built integrations.

Steps to Build the Integration :

Determine the API Structure : Review the third-party system's API documentation to understand the available endpoints, data formats (e.g., JSON, XML), and request/response structure.

Identify Authentication Protocols : Determine how the third-party system handles authentication (e.g., API keys, OAuth 2.0, Basic Auth).

Configure the Universal Connector : Use modules like HTTP Request or Webhook to make API calls to the third-party system based on the documented structure.

Why Not Other Options?

B. Create a new connection to the third-party system in the connections area and then the Universal Connectors will be available for use : Creating a new connection in the connections area is only applicable for predefined connectors, not for Universal Connectors, which require manual configuration for unsupported systems.

C. Use the Workfront Custom API module to set up the connection using API calls to the third-party system : The Workfront Custom API module is specifically designed for Workfront’s own API, not for connecting to third-party systems.

References :

Adobe Workfront Fusion Documentation: Using Universal Connectors for Custom Integrations

Experience League Community: Integrating Third-Party Systems Using Workfront Fusion Universal Modules

Step-by-Step Explanation

Purpose of the Query :

The task is to retrieve field options from a custom form field . This operation involves fetching data, not creating or modifying it, which requires a GET method.

Correct API Structure :

The URL must follow Workfront's API structure:

ruby

Copy

https://{your-workfront-domain}/attask/api/{version}/{endpoint}

Option B follows this standard structure, where:

wfdomain.workfront.com is the placeholder for the Workfront instance.

/attask/api/v12.0 specifies the API version.

/PARAM/search is the endpoint to search for parameters or fields.

Why Not Other Options?

A : The use of POST is incorrect because it is meant for creating or updating resources, not retrieving data. Additionally, the URL structure is incorrect and includes unnecessary query strings (username, password) not relevant for this operation.

C : While the method GET is correct, the URL (PARAM/search) is incomplete and lacks the required Workfront API structure, making it invalid.

References

Workfront API Documentation: Querying and Retrieving Custom Form Field Data

Experience League Community: Best Practices for Using GET Methods in Workfront API =========================

Step by Step Comprehensive Detailed Explanation :

Problem Summary :

The organization requires a process to track every project update made by Fusion to meet compliance standards.

This process must provide a clear audit trail of updates, including details like user and timestamp.

Option Analysis :

A. Use reporting on the Last Updated by ID and Last Update Date :

While this provides basic reporting, it only reflects the most recent update and does not maintain a comprehensive history of changes over time.

B. Update the External Reference ID with User ID and Timestamp :

Updating the External Reference ID could cause issues if this field is used for other purposes. It is not designed for logging multiple updates.

C. Create a Note record related to the record updated :

Correct. Creating a Note record for each update ensures that every change is logged with relevant details (e.g., user, timestamp, update reason). This approach creates a full audit trail that is easily accessible and reportable.

Why Note Records are Best :

Audit Trail : Notes provide a clear and searchable history of updates for each project.

Compliance : Ensures compliance by documenting who made what changes and when.

Flexibility : Notes can include custom details such as update reasons or additional context, making them more robust than standard fields.

Implementation :

In the Fusion scenario, add a module to create a Note record after each update.

Populate the Note with relevant details, such as:

User ID ({lastUpdatedBy})

Timestamp ({lastUpdateDate})

Description of the change.