AD0-E902 Adobe Workfront Fusion Professional Question and Answers

Understanding the Requirement:

The user wants to upload a document into Workfront and attach it to a specific task.

This action involves creating a document in Workfront and associating it with a task as a related record.

Why Option B is Correct:

TheUpload Documentmodule is specifically designed for uploading files into Workfront.

It includes the ability to set arelated record(e.g., a task, project, or issue) to which the document will be attached.

This ensures the document is uploaded and correctly linked to the task in a single operation.

Why the Other Options are Incorrect:

Option A ("Create Record for Document Version after Create Record for the document on the task"):

This involves multiple steps, which are unnecessary. TheUpload Documentmodule already handles both the upload and the attachment in one action.

Option C ("Create Record of Document type while setting the related record"):

TheCreate Recordmodule is not designed for file uploads. It only creates metadata records, not the actual document.

Option D ("Miscellaneous Action to attach document to a task"):

There is noMiscellaneous Actionspecifically for attaching a document to a task. TheUpload Documentmodule is the appropriate choice.

Steps to Upload a Document in Workfront Fusion:

Add theUpload Documentmodule to the scenario.

Specify the file to upload (e.g., from a previous module like Google Drive or an HTTP request).

Set therelated recordto the target task by providing its ID.

Run the scenario to upload and attach the document to the task.

References and Supporting Documentation:

Adobe Workfront Fusion: Upload Document Module

Workfront Community: Best Practices for Document Management in Fusion

The Upload Document module is the most efficient and accurate method for uploading and attaching a document to a task in Workfront.

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:

TheSwitchfunction 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 Diagram:

The image depicts a Workfront Fusion scenario usingRoutersto split and manage multiple execution paths.

Fusion executes modules in aleft-to-rightandtop-to-bottomsequence along each path. Routers direct the flow to downstream modules.

Determining the Execution Sequence:

Path 1:

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

Path 2:

The second path starts withEmailand 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 becauseWorkfrontdoes not precedeData Storein the execution order.

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

Incorrect because execution begins withGoogle Drive, not Email.

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

Incorrect because it excludesGoogle Driveas 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 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 indicates29 bundlesof project data were retrieved.

Each bundle contains fields such asID,name, andplannedCompletionDate.

Tools Module (Second Module):

The data from the Workfront module is processed to set variables likeProject NameandProject 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 theWorkfront moduleretrieved 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 theinput and output fields in the Tools moduleare 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 Scenario:

The issue involves end users inputting inconsistent date and currency formats that result in errors in a Workfront Fusion scenario.

The default behavior of Fusion stops the scenario after three retries due to input mismatches or invalid formats.

Why Option A is Correct:

Storing Incomplete Executions: In Adobe Workfront Fusion, enabling "Store incomplete executions" in the scenario settings allows administrators to capture incomplete runs without fully stopping the entire process. This feature stores all relevant data, even from incomplete runs, allowing administrators to identify and correct input issues manually.

Error Troubleshooting: By reviewing incomplete executions, admins can pinpoint where the scenario failed, resolve the issue, and potentially reprocess those incomplete records, preventing complete scenario stoppage.

Why Option B is Incorrect:

The "switch module" can handle specific input variations, but it is not a comprehensive solution for handling unexpected or inconsistent formats entered by end users. While it might mitigate some errors, it does not address the root cause and can miss unanticipated input patterns.

Why Option C is Incorrect:

Setting up an error handling path to notify users and request corrections adds an additional manual step for users but does not resolve the problem efficiently within Fusion. Moreover, this solution does not prevent the scenario from halting after retries.

Steps to Enable Storing Incomplete Executions:

Navigate to the scenario in Adobe Workfront Fusion.

Open theScenario Settingsby clicking the gear icon.

Enable the optionStore Incomplete Executionsunder Execution settings.

Save the settings and activate the scenario.

How This Solves the Problem:

Enabling this setting ensures that no data is lost when the scenario fails due to inconsistent inputs. Admins can access the incomplete executions through the scenario execution history, apply necessary corrections, and retry specific records or steps as needed.

References and Supporting Documentation:

Adobe Workfront Fusion Official Documentation: Scenario Settings

Workfront Community: Handling Incomplete Executions

Step by Step Comprehensive Detailed Explanation:

Understanding the Error:

The error message [403] The caller does not have permission is aGoogle API permission error.

It typically indicates that the user or application does not have the required access rights to perform the requested action on the Google Slide presentation.

Option Analysis:

A. Reauthorize their Google connection:

This step might be necessary if the user's credentials or token have expired, but this is not the primary issue here since the error specifically states apermission problem.

B. Update Google sharing permissions for the document:

Correct. The error suggests that the Google Slide document has not been shared with the user or service account being used in Fusion. Updating the sharing settings to grant proper permissions (e.g., "Editor" or "Viewer" access) will resolve the issue.

C. Contact Workfront Support to troubleshoot the root cause:

While Workfront Support can help with Fusion-related issues, this error originates from Google and is unrelated to Workfront's systems.

D. Search the Google status site to determine the cause:

The Google status site is useful for identifying system-wide outages, but this is a user-specific permission issue, not a Google platform-wide problem.

Steps to Resolve:

Open the Google Slide presentation.

Update the sharing permissions:

Grant access to the Google account or service account being used in Fusion.

Ensure the account has at leastEditoror appropriate access rights.

Save the changes and rerun the Fusion scenario.

Why Updating Permissions is Best:

This action directly addresses the root cause of the error, which is inadequate access rights.

Once permissions are updated, Fusion will be able to connect to and manipulate the Google Slide document as intended.

References:The [403] The caller does not have permission error is documented in Google API troubleshooting guides, which recommend verifying and updating document sharing settings for resolving access issues.

Step 1: Query Workfront for User Based on Email Address

Salesforce provides the email address of the user. Since Workfront uses user IDs for task assignments, the email address can be used as a unique identifier to query Workfront’s database.

A query module in Workfront Fusion retrieves the corresponding Workfront user ID using the provided email address.

Step 2: Assign Task Using Returned ID

After retrieving the Workfront user ID, use it in the assignment field of the task module in Fusion.

The task assignment process requires a valid user ID, ensuring proper linkage and assignment within Workfront.

Why Not Other Options?

A. Assign the task using the provided user ID > add the user ID to the assignment field: The Salesforce user ID is not recognized by Workfront. It is necessary to query Workfront to convert the email into a Workfront-compatible user ID.

C. Query Workfront based on the user's name > assign task using returned email address: Workfront uses user IDs, not email addresses, for task assignments. Names are also not unique and could cause assignment errors.

References:

Adobe Workfront Fusion Documentation: Task Assignments Using User IDs

Experience League Community: Mapping Salesforce Data to Workfront Tasks

Understanding HTTP Response Codes:HTTP response codes are standardized codes that indicate the result of a request made to a server:

2xx (Success): Indicates that the request was successfully received, understood, and processed by the server.

200 OK: Specifically means that the request was successful, and the response contains the requested data or confirms the operation's success.

Response Code for Creating a Record:

When using an HTTP module in Fusion to create a new record, a response code of200confirms that the request to the server was successfully processed and the record creation was successful.

Why Not Other Options?

A. GREEN: This is not a valid HTTP response code. It might represent a status in some systems but is unrelated to HTTP standards.

C. 402: This code indicates a payment required error, meaning the request cannot be fulfilled until payment is made.

D. 500: This is a server-side error, indicating that something went wrong on the server during processing.

References:

HTTP Status Code Documentation: 200 Success Response

Adobe Workfront Fusion Documentation: HTTP Module and Response Codes

Object ID in CRUD Operations:REST APIs commonly use CRUD operations to interact with resources. TheObject IDserves as a unique identifier for the resource and is generally required for the following actions:

A. Update:

To update a specific resource, the API must know which resource to modify. The Object ID is used to identify the exact resource that should be updated.

Example: A PUT or PATCH request typically requires the Object ID in the URL or body of the request.

URL Example:

PUT /tasks/{id}

B. Delete:

Similarly, when deleting a specific resource, the Object ID is needed to ensure the correct resource is removed.

Example: A DELETE request requires the Object ID in the URL to target the specific resource.

URL Example:

DELETE /tasks/{id}

Why Not Other Options?

C. Respond: This is not a standard CRUD operation in REST APIs and does not involve an Object ID.

D. Create: The Create operation (typically POST) does not require an Object ID because the resource does not yet exist. Instead, the API usually generates the Object ID after creation.

References:

REST API Documentation Best Practices: CRUD Operations

Experience League: Understanding CRUD in Workfront APIs

Understanding the Requirement:

The input is an array containing objects, and the goal is to extract all the stat.name values into acomma-separated string.

Example Input:

[

{

"base_stat": 48,

"effort": 1,

"stat": {

"name": "hp",

"url": "https://pokeapi.co/api/v2/stat/1/"

}

},

{

"base_stat": 48,

"effort": 0,

"stat": {

"name": "attack",

"url": "https://pokeapi.co/api/v2/stat/2/"

}

}

]

Example Output:"hp, attack"

Why Option B is Correct:

The expressionjoin(map(2.data: stats[]; stats.stat.name); ", "):

map: Iterates through each object in the array (2.data: stats[]) and extracts the stat.name field.

join: Combines the extracted values into a single string, separated by a comma and space (", ").

Breaking it down:

map(2.data: stats[]; stats.stat.name) → Creates an array of names: ["hp", "attack"].

join(...; ", ") → Converts the array into the string "hp, attack".

Why the Other Options are Incorrect:

Option A: join(2.data: stats[]; stat.name; ", ")

This syntax is incorrect because it attempts to directly access stat.name within the join function without first mapping the values.

Option C: join(map(2.data: stats[]; stat.name); ", ")

The mapping references stat.name directly but does not account for the nested structure (stats.stat.name).

Option D: join(flatten(2.data: stats[]); ", ")

The flatten function is unnecessary here as the data is already structured. It would not properly extract the stat.name values.

Steps to Implement in Workfront Fusion:

Add aMapping/Transformation Module.

Use the join(map(...)) function as described to transform the input array into a comma-separated string.

Test the output to ensure it correctly generates the desired format.

How This Solves the Problem:

The map function ensures the proper extraction of nested stat.name values.

The join function combines these values into the desired format efficiently.

References and Supporting Documentation:

Adobe Workfront Fusion Functions Documentation

Workfront Community: Using Map and Join Functions

The combination of map and join ensures that the stat names are extracted and formatted into a single comma-separated string, as required.

Understanding the Issue:

The customer is syncing20,000+ Salesforce Opportunitieswith Workfront projects using a scheduled Fusion scenario.

After running for 40 minutes, the scenario unexpectedly stops.

Why Option C is Correct:

Workfront Fusion Execution Timeout:

Fusion scenarios have a default execution timeout of40 minutesper run.

If the scenario exceeds this time limit, Fusion automatically stops the execution to avoid resource overuse.

Handling Large Data Sets:

Scenarios involving large datasets (like syncing 20,000+ records) may require optimizations, such as breaking the data into smaller chunks using paginated requests or iterators.

In this case, the scenario stopped because the execution timeout was reached, not due to API limits or webhook restrictions.

Why the Other Options are Incorrect:

Option A ("Workfront API call limit"):

While Workfront does have API rate limits, they are generally generous and not the reason for the scenario stopping. Fusion scenarios are designed to manage API calls efficiently.

Option B ("Fusion times out if processing over 2000 records in 40 minutes"):

This is incorrect because Fusion does not have a hard limit on the number of records processed in 40 minutes. The timeout is time-based, not record-based.

Option D ("Workfront API stops webhooks after 2000 hits in 10 minutes"):

This does not apply to Fusion scenarios. Webhooks are separate from the API calls initiated by Fusion.

How to Resolve the Issue:

Split the Data: Use pagination or batch processing to divide the 20,000+ records into smaller chunks (e.g., 1,000 or 2,000 records per run).

Adjust Scheduling: Schedule the scenario to run more frequently with smaller batches, ensuring all records are synced over multiple runs.

Use Iterators: Add an Iterator module to loop through smaller subsets of data, preventing the scenario from exceeding the execution timeout.

Steps to Optimize the Scenario:

Add aSearch Moduleto retrieve opportunities in smaller batches (e.g., using limits or pagination parameters).

Use aRepeater Moduleto process each batch iteratively.

Save the scenario and schedule it to run nightly or more frequently, depending on the sync requirements.

References and Supporting Documentation:

Adobe Workfront Fusion: Execution Timeout Limits

Workfront Community: Managing Large Data Sets in Fusion Scenarios

By optimizing the scenario to handle smaller batches of data, the admin can avoid the execution timeout issue and ensure successful syncing of Salesforce Opportunities with Workfront projects.

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