Workday-Pro-Integrations Workday Pro Integrations Certification Exam Questions and Answers

The element is a fundamental component of XSLT (Extensible Stylesheet Language Transformations), which is widely used in Workday integrations, particularly within document transformation systems such as those configured via the Enterprise Interface Builder (EIB) or Document Transformation Connectors. Its primary purpose is to define rules or instructions that dictate how specific nodes in an XML source document should be processed and transformed into the desired output format.

Here’s a detailed explanation of why this is the correct answer:

In XSLT, the element is used to create reusable transformation rules. It typically includes a match attribute, which specifies the XML node or pattern (e.g., an element, attribute, or root node) to which the template applies. For example, would target all elements in the source XML.

Inside the element, you define the logic—such as extracting data, restructuring it, or applying conditions—that determines how the matched node is transformed into the output. This makes it a core mechanism for controlling the transformation process in Workday integrations.

In the context of Workday, where XSLT is often used to reformat XML data into formats like CSV, JSON, or custom XML for external systems, provides the structure for specifying how data from Workday’s XML output (e.g., payroll or HR data) is mapped and transformed.

Let’s evaluate why the other options are incorrect:

A. Determine the output file type: The element does not control the output file type (e.g., XML, text, HTML). This is determined by the element in the XSLT stylesheet, which defines the format of the resulting file independently of individual templates.

B. Grant access to the XSLT language: This option is nonsensical in the context of XSLT. The element is part of the XSLT language itself and does not "grant access" to it; rather, it is a functional building block used within an XSLT stylesheet.

D. Generate an output file name: The element has no role in naming the output file. In Workday, the output file name is typically configured within the integration system settings (e.g., via the EIB or connector configuration) and is not influenced by the XSLT transformation logic.

An example of in action might look like this in a Workday transformation:

Here, the template matches the Worker node in Workday’s XML schema and transforms it into a simpler structure with a Name element, demonstrating its role in providing rules for node transformation.

References:

Workday Pro Integrations Study Guide: "Configure Integration System - TRANSFORMATION" section, which explains XSLT usage in Workday and highlights as the mechanism for defining transformation rules.

Workday Documentation: "XSLT Transformations in Workday" under the Document Transformation Connector, noting as critical for node-specific processing.

W3C XSLT 1.0 Specification (adopted by Workday): Section 5.3, "Defining Template Rules," which confirms that provides rules for applying transformations to specified nodes.

Workday Community: Examples of XSLT in integration scenarios, consistently using for transformation logic.

The scenario involves a Core Connector: Candidate Outbound integration requiring a calculated field for the average number of jobs a candidate applied to, which isn’t a delivered Workday field. The task is to output this calculated field in the integration file. Core Connectors in Workday use predefined templates but allow customization through various configuration options. Let’s evaluate the steps:

Context:

Core Connector: Candidate Outbound uses the Data Initialization Service (DIS) to extract candidate data.

A calculated field must be created (e.g., averaging the "Number of Job Applications" field across a candidate’s records).

This value needs to be included in the output file sent to the vendor.

Integration Field Overrides:In Core Connectors, calculated fields are typically incorporated into the output by definingintegration field overrides. This feature allows you to map a calculated field to a specific field in the connector’s output structure, overriding the default delivered value (or adding a new field). The calculated field is built separately (e.g., in Report Writer or Calculated Fields) and then referenced in the integration configuration.

Option Analysis:

A. Configure a custom field override service to output the calculation: Incorrect. There’s no "custom field override service" in Workday Core Connectors. This might confuse with integration field overrides, but it’s not a distinct service.

B. Configure integration attributes to output the calculation: Incorrect. Integration attributes define metadata or settings for the integration (e.g., file name, delivery method), not specific field mappings for output data.

C. Configure integration field attributes to output the calculation: Incorrect. "Integration field attributes" isn’t a precise Workday term for this purpose; it may confuse with field-level settings, but field overrides are the correct mechanism.

D. Configure integration field overrides to output the calculation: Correct. This is the standard method in Core Connectors to include calculated fields in the output file by overriding or adding to the delivered field structure.

Implementation:

Create a calculated field (e.g., "Average Job Applications") using functions like Arithmetic Calculation to average job application counts.

In the Core Connector configuration, navigate to theIntegration Field Overridessection.

Define a new field or override an existing one, mapping it to the calculated field.

Test the integration to ensure the calculated value appears in the output file.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on "Configuring Integration Field Overrides" explains mapping calculated fields to output files.

Integration System Fundamentals: Details how Core Connectors extend delivered functionality with custom calculations.

For an XSLT (Extensible Stylesheet Language Transformations) file to be considered valid in the context of Workday integrations (and per general XSLT standards), it must adhere to specific structural and functional requirements. The correct answer is that an XSLT file must containa root element,a namespace, andat least one template. Below is a detailed explanation of why this is the case, grounded in Workday’s integration practices and XSLT specifications:

Root Element:

Every valid XSLT file must have a single root element, which serves as the top-level container for the stylesheet. In XSLT, this is typically the or element (both are interchangeable, though is more common).

The root element defines the structure of the XSLT document and encapsulates all other elements, such as templates and namespaces. Without a root element, the file would not conform to XML well-formedness rules, which are a prerequisite for XSLT validity.

Example:

Namespace:

An XSLT file must declare the XSLT namespace, typically http://www.w3.org/1999/XSL/Transform, to identify it as an XSLT stylesheet and enable the processor to recognize XSLT-specific elements (e.g., , ). This is declared within the root element using the xmlns:xsl attribute.

The namespace ensures that the elements used in the stylesheet are interpreted as XSLT instructions rather than arbitrary XML. Without this namespace, the file would not function as an XSLT stylesheet, as the processor would not know how to process its contents.

In Workday’s Document Transformation integrations, additional namespaces (e.g., for Workday-specific schemas) may also be included, but the XSLT namespace is mandatory for validity.

At Least One Template:

An XSLT file must contain at least one element to define the transformation logic. Templates are the core mechanism by which XSLT processes input XML and produces output. They specify rules for matching nodes in the source XML (via the match attribute) and generating the transformed result.

Without at least one template, the stylesheet would lack any transformation capability, rendering it functionally invalid for its intended purpose. Even a minimal XSLT file requires a template to produce meaningful output, though built-in default templates exist, they are insufficient for custom transformations like those used in Workday.

Example:

Hello, Workday!

Complete Minimal Valid XSLT Example:

Transformed Data

Why Other Options Are Incorrect:

A. A root element, namespace, and at least one transformation: While this is close, "transformation" is not a precise term in XSLT. The correct requirement is a "template," which defines the transformation logic. "Transformation" might imply the overall process, but the specific feature required in the file is a template.

C. A header, a footer, and a namespace: XSLT files do not require a "header" or "footer." These terms are not part of XSLT or XML standards. The structure is defined by the root element and templates, not headers or footers, making this option invalid.

D. A template, a prefix, and a header: While a template is required, "prefix" (likely referring to the namespace prefix like xsl:) is not a standalone feature—it’s part of the namespace declaration within the root element. "Header" is not a required component, making this option incorrect.

Workday Context:

In Workday’s Document Transformation systems (e.g., Core Connectors or custom integrations), XSLT files are uploaded as attachment transformations. Workday enforces these requirements to ensure the stylesheets can process XML data (e.g., from Workday reports or connectors) into formats suitable for external systems. The Workday platform validates these components whenan XSLT file is uploaded, rejecting files that lack a root element, namespace, or functional templates.

Workday Pro Integrations Study Guide References:

Workday Integration System Fundamentals: Describes the structure of XSLT files, emphasizing the need for a root element (), the XSLT namespace, and templates as the building blocks of transformation logic.

Document Transformation Module: Details the requirements for uploading valid XSLT files in Workday, including examples that consistently feature a root element, namespace declaration, and at least one template (e.g., "XSLT Basics for Document Transformation").

Core Connectors and Document Transformation Course Manual: Provides sample XSLT files used in labs, all of which include these three components to ensure functionality within Workday integrations.

Workday Community Documentation: Reinforces that XSLT files must be well-formed XML with an XSLT namespace and at least one template to be processed correctly by Workday’s integration engine.

In Workday, after configuring an Integration System User (ISU) and an Integration System Security Group (ISSG) with the appropriate security policies and assigning them to an Enterprise Interface Builder (EIB) integration, there is a critical step required before the EIB can be launched successfully. This step ensures that all security configurations and permissions assigned to the ISSG take effect in the Workday tenant. Let’s analyze the question and evaluate each option systematically to determine the correct task, ensuring the answer aligns with Workday’s documented processes and the Workday Pro Integrations Study Guide.

Context of the Scenario

You’ve completed the following:

Created an ISU and configured it (e.g., with "Do Not Allow UI Sessions" checked for web service-only access).

Set up an ISSG and assigned the ISU to it.

Defined the necessary security policies (e.g., domain security policies with "Get" and/or "Put" access) for the ISSG to support the EIB’s operations.

Assigned the ISU and ISSG to the EIB integration system.

The question now is what must be done before launching the EIB to ensure it functions as intended. In Workday, changes to security policies—such as adding permissions to an ISSG—do not take effect immediately. They remain in a "pending" state until activated, which is a key aspect of Workday’s security administration process.

Evaluation of Options

Option A: Activate Pending Security Policy ChangesIn Workday, whenever you modify security policies (e.g., granting domain permissions like "Integration Build" or "Custom Report Creation" to an ISSG), these changes are staged as "pending." To apply them to the tenant and make them active, you must run the "Activate Pending Security Policy Changes" task. This task reviews all pending security updates, allows you to add a comment for audit purposes, and, upon confirmation, activates the changes. Without this step, the ISSG will not have the effective permissions required for the EIB to access data or execute its operations, potentially causing the launch to fail due to insufficient authorization. This aligns directly with the scenario, as security policies have been configured and assigned, but not yet activated.

Option B: View Security for Securable ItemThe "View Security for Securable Item" report is a diagnostic tool in Workday that allows you to inspect the security configuration for a specific object (e.g., a web service operation, report, or task). It shows which security groups have access and what permissions (e.g., "Get," "Put," "View," "Modify") are granted. While this is useful for verifying that the ISSG has the correct policies assigned, it is a passive report—it does not modify or activate anything. Running this task would not enable the EIB to launch, as it doesn’t affect the pending security changes. Thus, it’s not the required step before launching the EIB.

Option C: Assign the ISSG to only one security policyThis option suggests limiting the ISSG to a single security policy, but this is neither a standard Workday requirement nor a task that exists as a standalone action. ISSGs can and often do havemultiple security policies assigned (e.g., permissions for various domains like "Integration Build," "Custom Report Access," etc.), depending on the integration’s needs. Moreover, the question states that the ISSG has already been configured with the "correct security policies" and assigned to the EIB, implying this step is complete. Restricting the ISSG to one policy after the fact would require editing permissions again, triggering more pending changes, and still necessitate activation—making this option illogical and incorrect.

Option D: Maintain Integration Security PoliciesThere is no specific task in Workday called "Maintain Integration Security Policies." This option seems to be a misnomer or a conflation of other tasks, such as "Maintain Domain Permissions for Security Group" (used to assign permissions to an ISSG) or broader security maintenance activities. However, the question indicates that the security policies are already correctly configured and assigned. If this option intended to imply further configuration, it would still result in pending changes requiring activation via Option A. As a standalone action, it does not represent a valid or necessary task to enable the EIB launch.

Why Option A is Correct

The "Activate Pending Security Policy Changes" task is a mandatory step in Workday’s security workflow after modifying security policies, such as those assigned to an ISSG for an EIB. Workday’s security model uses a pending changes queue to ensure that updates are reviewed and deliberately applied, maintaining control and auditability. Without activating these changes:

The ISSG will lack the effective permissions needed for the EIB to access required domains or perform its operations (e.g., retrieving data from a custom report or delivering a file).

The EIB launch could fail with errors like "Insufficient Privileges" or "Access Denied."

Running this task ensures that the security configuration is live, allowing the ISU (via the ISSG) to authenticate and execute the EIB successfully. This is a standard practice in Workday integration setup, as emphasized in the Workday Pro Integrations curriculum.

Practical Steps to Perform Option A

Log into the Workday tenant with a security administrator role.

Search for and select the "Activate Pending Security Policy Changes" task.

Review the list of pending changes (e.g., new permissions added to the ISSG).

Enter a comment (e.g., "Activating security for EIB launch – ISSG permissions").

Check the "Confirm" box and click "OK" to activate the changes.

Once completed, the security policies are live, and the EIB can be launched.

Verification with Workday Documentation

The Workday Pro Integrations Study Guide and related training materials confirm that activating pending security policy changes is a prerequisite after configuring security for integrations. This step ensures that all permissions are in effect, enabling the ISU and ISSG to support the EIB’s functionality. Community resources and implementation guides also consistently highlight this task as the final step before launching integrations that rely on updated security settings.

Workday Pro Integrations Study Guide References

Section: Integration Security Configuration– Explains the process of assigning security policies to ISSGs and the need to activate changes to operationalize them.

Section: Enterprise Interface Builder (EIB)– Notes that security updates for EIBs must be activated before launching to ensure proper access.

Section: Security Administration– Details the "Activate Pending Security Policy Changes" task as the mechanism to apply pending security modifications across the tenant.

In Workday, when refining a custom report to include specific conditions such as limiting the output to workers hired in the last 30 days, the appropriate place to specify this condition is within theFiltertab of the custom report definition. The Filter tab allows you to define criteria that determine which instances of the primary business object (in this case, "Worker") are included in the report output. This is critical for integrations, as the filtered data ensures that only relevant records are sent to the third-party system.

The requirement here is to restrict the report to workers hired within the last 30 days. In Workday reporting, this can be achieved by adding a filter condition on the "Hire Date" field of the Worker business object. Specifically, you would configure the filter to compare the "Hire Date" against a dynamic date range, such as "Current Date minus 30 days" to "Current Date." This ensures the report dynamically adjusts to include only workers hired in the last 30 days each time it runs, which aligns with the needs of an integration sending real-time data to a third-party system.

Here’s why the other options are incorrect:

A. Subfilter: Subfilters in Workday are used to further refine data within a related business object or a subset of data already filtered by the primary filter. They are not the primary mechanism for applying a condition to the main dataset (e.g., all workers). For this scenario, asubfilter would be unnecessary since the condition applies directly to the Worker business object, not a related object.

B. Output: The Output section of a custom report definition controls how the report is displayed or delivered (e.g., file format, scheduling), not the data selection criteria. It does not allow for specifying conditions like hire date ranges.

C. Columns: The Columns tab defines which fields are displayed in the report output (e.g., Worker ID, Name, Hire Date). While you can add the "Hire Date" field here for visibility, it does not control which workers are included in the report—that is the role of the Filter tab.

To implement this in practice:

In the custom report definition, go to theFiltertab.

Add a new filter condition.

Select the "Hire Date" field from the Worker business object.

Set the operator to "in the range" and define the range as "Current Date - 30 days" to "Current Date" (using dynamic date functions available in Workday).

Save and test the report to ensure it returns only workers hired within the last 30 days.

This filtered report can then be enabled as a web service (via the Advanced tab) or used in an Enterprise Interface Builder (EIB) or Workday Studio integration to send the data to the third-party system, meeting the integration requirement.

References from Workday Pro Integrations Study Guide:

Workday Report Writer Fundamentals: Section on "Creating and Managing Filters" explains how filters are used to limit report data based on specific conditions, such as date ranges.

Integration System Fundamentals: Discusses how custom reports serve as data sources for integrations and the importance of filters in defining the dataset.

Core Connectors & Document Transformation: Highlights the use of filtered custom reports in outbound integrations to third-party systems.

When setting up security for a Core Connector integration system in Workday, you need to know which web service operation the connector template uses. The best way is to run the "Integration Template Catalog report" within your Workday tenant. This report lists all integration templates and should include details about the web service operations they use, making it easy to configure security.

Why This Matters

This method is efficient because it lets you find the information before running the system, which is crucial for setting up permissions correctly. It's surprising that such a specific report exists, as it simplifies a task that could otherwise involve running the system or guessing from API references.

How It Works

Select the report in your Workday tenant to see a list of all Core Connector templates.

Look for the template you're using and find the associated web service operation listed in the report.

Use this information to set up the right security permissions for your integration.

For more details, check out resources likeWorkday Core ConnectorsorWorkday Integrations.

The scenario involves a Core Connector: Worker integration using the Data Initialization Service (DIS) to export a full file of employee personal data, with a requirement to include a calculated field in the output. Core Connectors rely on predefined field mappings, but custom calculated fields need specific configuration to be included. Let’s analyze the solution:

Requirement:Output the value of a calculated field created for this integration. In Workday, calculated fields are custom-built (e.g., using Report Writer or Calculated Fields) and not part of the standard Core Connector template, so they must be explicitly added to the output.

Integration Field Overrides:In Core Connectors,Integration Field Overridesallow you to replace a delivered field’s value or add a new field to the output by mapping it to a calculated field. This is the standard method to include custom calculated fields in the integration file. You create the calculated field separately,then use overrides to specify where its value appears in the output structure (e.g., as a new column or replacing an existing field).

Option Analysis:

A. Configure Integration Field Attributes: Incorrect. Integration Field Attributes refine how delivered fields are output (e.g., filtering multi-instance data like phone type), but they don’t support adding or mapping calculated fields.

B. Configure Integration Field Overrides: Correct. This configuration maps the calculated field to the output, ensuring its value is included in the exported file.

C. Configure Integration Attributes: Incorrect. Integration Attributes define integration-level settings (e.g., file name, delivery protocol), not field-specific outputs like calculated fields.

D. Configure Integration Maps: Incorrect. Integration Maps transform existing field values (e.g., "Married" to "M"), but they don’t add new fields or directly output calculated fields.

Implementation:

Create the calculated field in Workday (e.g., via Create Calculated Field task).

Edit the Core Connector: Worker integration.

Navigate to theIntegration Field Overridessection.

Add a new override, selecting the calculated field and specifying its output position (e.g., a new field ID or overriding an existing one).

Test the integration to confirm the calculated field value appears in the output file.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on "Configuring Integration Field Overrides" explains how to include calculated fields in Core Connector outputs.

Integration System Fundamentals: Notes the use of overrides for custom data in predefined integration templates.

In Workday integrations, the Extension for Transformation and Validation (ETV) framework is used within XSLT transformations to apply validation and formatting rules to XML data, such as the output from a Core Connector (e.g., Positions integration). In this scenario, you need to perform an XSLT transformation on the Core Connector: Positions XML output file to display a hyperlink for positions that are not available for hiring as an entry in the Message tab. This requires configuring ETV attributes to ensure the data is present and correctly targeted for the hyperlink.

Here’s why option B is correct:

Requirement Analysis: The requirement specifies showing a hyperlink for positions "not available for hiring." In the provided XML, the ps:Available_For_Hire field under ps:Position_Data indicates whether a position is available for hire (e.g., true). For positions where this is false, you need to create a message (hyperlink) in the Message tab, which typically requires linking to a Workday ID (WID) or other identifier.

ETV Attributes:

etv:required="true": This ensures that the ps:WID value under ps:Additional_Information is mandatory for the transformation. If the WID is missing, the transformation will fail or generate an error, ensuring that the hyperlink can be created only for valid positions with an associated WID.

etv:target="[ps:Additional_Information/ps:WID]": This specifies that the target of the transformation (e.g., the hyperlink) should be the WID value found at ps:Additional_Information/ps:WID in the XML. This WID can be used to construct a hyperlink to the position in Workday, meeting the requirement to show a hyperlink for positions not available for hiring.

Context in XML: The XML shows ps:Additional_Information containing ps:WID (e.g., 73bd4d8562e04b1820f55818467905b), which is a unique identifier for the position. By targeting this WID with etv:target, you ensure the hyperlink points to the correct position record in Workday when ps:Available_For_Hire is false.

Why not the other options?

A.

etv:minLength="0"

etv:targetWID="[ps:Additional_Information/ps:WID]"

etv:minLength="0" allows the WID to be empty or have zero length, which contradicts the need for a valid WID to create a hyperlink. It does not ensure the data is present, making it unsuitable. Additionally, etv:targetWID is not a standard ETV attribute; the correct attribute is etv:target, making this option incorrect.

C.

etv:minLength="0"

etv:target="[ps:Additional_Information/ps:WID]"

Similar to option A, etv:minLength="0" allows the WID to be empty, which does not meet the requirement for a mandatory WID to create a hyperlink. This makes it incorrect, as the hyperlink would fail if the WID is missing.

D.

etv:required="true"

etv:targetWID="[ps:Additional_Information/ps:WID]"

While etv:required="true" ensures the WID is present, etv:targetWID is not a standard ETV attribute. The correct attribute is etv:target, making this option syntactically incorrect and unsuitable for the transformation.

To implement this in XSLT for a Workday integration:

Use the ETV attributes from option B (etv:required="true" and etv:target="[ps:Additional_Information/ps:WID]") within your XSLT template to validate and target the ps:WID for positions where ps:Available_For_Hire is false. This ensures the transformation generates a valid hyperlink in the Message tab, linking to the position’s WID in Workday.

References:

Workday Pro Integrations Study Guide: Section on "ETV in XSLT Transformations" – Details the use of ETV attributes like required and target for validating and targeting data in Workday XML, including handling identifiers like WID for hyperlinks.

Workday Core Connector and EIB Guide: Chapter on "XML Transformations" – Explains how to use ETV attributes in XSLT to process position data, including creating messages or hyperlinks based on conditions like Available_For_Hire.

Workday Integration System Fundamentals: Section on "ETV for Message Generation" – Covers applying ETV attributes to generate hyperlinks in the Message tab, ensuring data integrity and correct targeting of Workday identifiers like WID.

The task is to write XSLT within a template matching wd:Report_Data/wd:Report_Entry to categorize wd:Job_Skills data, outputting "HR Skills" if the value contains "HR" and "NON-HR Skills" if it does not, using a series of elements. The correct syntax must use the contains() function to check for the substring "HR" within wd:Job_Skills, as the question implies partial matching (e.g., "HR Specialist" or "Senior HR"), not exact equality.

Let’s analyze each option:

Option A:

xml

HR Skills

NON-HR Skills

Issues:

is misused here. It outputs the result of the expression (e.g., "true" or "false" for a comparison), not the conditional text. The inside won’t execute as intended.

The = operator checks for exact equality (e.g., wd:Job_Skills must be exactly "HR"), not substring presence, which contradicts the requirement to check if "HR" is contained within the value.

is malformed (self-closing without a test attribute) and misplaced.

Verdict: Incorrect syntax and logic.

Option B:

xml

HR Skills

NON-HR Skills

Issues:

Similar to A, outputs the boolean result of contains() ("true" or "false"), not the conditional text "HR Skills" or "NON-HR Skills."

The elements are inside invalid tags (self-closing, no test), rendering them ineffective.

While contains() is correct for substring checking, the structure fails to meet the requirement.

Verdict: Incorrect structure despite using contains().

Option C:

xml

HR Skills

NON-HR Skills

Analysis:

Uses correctly with test attributes, satisfying the "series of elements" requirement.

However, wd:Job_Skills='HR' tests for exact equality, not whether "HR" is contained within the value. For example, "HR Specialist" would fail this test, outputting "NON-HR Skills" incorrectly.

Verdict: Semantically incorrect due to exact matching instead of substring checking.

Option D:

xml

HR Skills

NON-HR Skills

Analysis:

Correctly uses with test attributes, aligning with the question’s requirement.

The contains() function properly checks if "HR" is a substring within wd:Job_Skills (e.g., "HR Manager" or "Senior HR" returns true).

not(contains()) ensures the opposite condition, covering all cases (mutually exclusive).

outputs the exact strings "HR Skills" or "NON-HR Skills" as required.

Note: The closing tag is a typo in the option (should be ), but in context, it’s an obvious formatting error, not a substantive issue.

Verdict: Correct logic and syntax, making D the best answer.

Correct Implementation in Context:

xml

HR Skills

NON-HR Skills

Example Input: Senior HR Analyst → Output: HR Skills

Example Input: IT Specialist → Output: NON-HR Skills

References:

Workday Pro Integrations Study Guide: "Configure Integration System - TRANSFORMATION" section, detailing and contains() for conditional XSLT logic in Workday.

Workday Documentation: "XSLT Transformations in Workday" under EIB, confirming wd: namespace usage and string functions.

W3C XSLT 1.0 Specification: Section 9.1, "Conditional Processing with ," and Section 11.2, "String Functions" (contains()).

Workday Community: Examples of substring-based conditionals in XSLT for report transformations.

The scenario involves a Core Connector: Worker integration with two runs detailed in the integration events report. The goal is to determine whether Brian Hill’s compensation change, effective April 30, 2024, and entered on May 13, 2024, will be included in either of the runs based on their date launch parameters. Let’s analyze each run against the change details to identify the correct answer.

In Workday, the Core Connector: Worker integration in incremental mode (as indicated by the presence of "Last Successful" parameters) processes changes based on the Transaction Log, filtering them by theEntry Moment(when the change was entered) andEffective Date(when the change takes effect). The integration captures changes where:

TheEntry Momentfalls between theLast Successful As of Entry Momentand theAs of Entry Moment, and

TheEffective Datefalls between theLast Successful Effective Dateand theEffective Date.

Brian Hill’s compensation change has:

Entry Moment:05/13/2024 (time not specified, so we assume it occurs at some point during the day, before or up to 11:59:59 PM).

Effective Date:04/30/2024.

Analysis of Run #1

Launch Date:05/15/2024 at 3:00:00 AM

As of Entry Moment:05/15/2024 3:00:00 AM – The latest point for when changes were entered.

Effective Date:05/15/2024 – The latest effective date for changes.

Last Successful As of Entry Moment:05/01/2024 3:00:00 AM – The starting point for entry moments.

Last Successful Effective Date:05/01/2024 – The starting point for effective dates.

For Run #1 to include Brian’s change:

TheEntry Moment(05/13/2024) must be between 05/01/2024 3:00:00 AM and 05/15/2024 3:00:00 AM. Since 05/13/2024 falls within this range (assuming the change was entered before 3:00:00 AM on 05/15/2024, which is reasonable unless specified otherwise), this condition is met.

TheEffective Date(04/30/2024) must be between 05/01/2024 (Last Successful Effective Date) and 05/15/2024 (Effective Date). However, 04/30/2024 isbefore05/01/2024, so this condition isnot met.

Since the effective date of Brian’s change (04/30/2024) precedes theLast Successful Effective Date(05/01/2024), Run #1 will not include this change. In incremental mode, Workday excludes changes with effective dates prior to the last successful effective date, as those are assumed to have been processed in a prior run (before Run #1’s baseline of 05/01/2024).

Analysis of Run #2

Launch Date:05/31/2024 at 3:00:00 AM

As of Entry Moment:05/31/2024 3:00:00 AM – The latest point for when changes were entered.

Effective Date:05/31/2024 – The latest effective date for changes.

Last Successful As of Entry Moment:05/15/2024 3:00:00 AM – The starting point for entry moments.

Last Successful Effective Date:05/15/2024 – The starting point for effective dates.

For Run #2 to include Brian’s change:

TheEntry Moment(05/13/2024) must be between 05/15/2024 3:00:00 AM and 05/31/2024 3:00:00 AM. However, 05/13/2024 isbefore05/15/2024 3:00:00 AM, so this condition isnot met.

TheEffective Date(04/30/2024) must be between 05/15/2024 (Last Successful Effective Date) and 05/31/2024 (Effective Date). Since 04/30/2024 isbefore05/15/2024, this condition is alsonot met.

In Run #2, theEntry Moment(05/13/2024) precedes theLast Successful As of Entry Moment(05/15/2024 3:00:00 AM), meaning the change was entered before the starting point of this run’s detection window. Additionally, theEffective Date(04/30/2024) is well before theLast Successful Effective Date(05/15/2024). Both filters exclude Brian’s change from Run #2.

Conclusion

Run #1:Excluded because the effective date (04/30/2024) is before the Last Successful Effective Date (05/01/2024).

Run #2:Excluded because the entry moment (05/13/2024) is before the Last Successful As of Entry Moment (05/15/2024 3:00:00 AM) and the effective date (04/30/2024) is before the Last Successful Effective Date (05/15/2024).

Brian Hill’s change would have been processed in an earlier run (prior to May 1, 2024) if the integration was running incrementally before Run #1, as its effective date (04/30/2024) predates both runs’ baselines. Given the parameters provided, neither Run #1 nor Run #2 captures this change, makingD. Brian Hill will be excluded from both integration runsthe correct answer.

Workday Pro Integrations Study Guide References

Workday Integrations Study Guide: Core Connector: Worker– Section on "Incremental Processing" explains how changes are filtered based on entry moments and effective dates relative to the last successful run.

Workday Integrations Study Guide: Launch Parameters– Details how "Last Successful As of Entry Moment" and "Last Successful Effective Date" define the starting point for detecting new changes, excluding prior transactions.

Workday Integrations Study Guide: Change Detection– Notes that changes with effective dates before the last successful effective date are assumed processed in earlier runs and are skipped in incremental mode.

The scenario involves a Core Connector: Worker integration using DIS to export a full file of employee personal data, with the requirement to output only the home phone number when including phone data. Workday’s "Phone Number" field is multi-instance, meaning a worker can have multiple phone types (e.g., Home, Work, Mobile). Let’s determine the configuration:

Requirement:Filter the multi-instance "Phone Number" field to include only the "Home" phone number in the output file. This involves specifying which instance of the phone data to extract.

Integration Field Attributes:In Core Connectors,Integration Field Attributesallow you to refine how multi-instance fields are handled in the output. For the "Phone Number" field, you can set an attribute like "PhoneType" to "Home" to ensure only home phone numbers are included. This is a field-level configuration that filters instances without requiring a calculated field or override.

Option Analysis:

A. Configure an integration map to map the phone type: Incorrect. Integration Maps transform field values (e.g., "United States" to "USA"), not filter multi-instance data like selecting a specific phone type.

B. Include the phone type integration field attribute: Correct. This configures the "Phone Number" field to output only instances where the phone type is "Home," directly meeting the requirement.

C. Configure the phone type integration attribute: Incorrect. "Integration attribute" refers to integration-level settings (e.g., file format), not field-specific configurations. The correct term is "integration field attribute."

D. Configure an integration field override to include phone type: Incorrect. Integration Field Overrides are used to replace a field’s value with a calculated field or custom value, not to filter multi-instance data like phone type.

Implementation:

Edit the Core Connector: Worker integration.

Navigate to theIntegration Field Attributessection for the "Phone Number" field.

Set the "Phone Type" attribute to "Home" (or equivalent reference ID for Home phone).

Test the output file to confirm only home phone numbers are included.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on "Integration Field Attributes" explains filtering multi-instance fields like phone numbers by type.

Integration System Fundamentals: Notes how Core Connectors handle multi-instance data with field-level attributes.

To create a connector-based integration with additional custom configurations such as dynamic file naming and internal-to-external value mapping, the following steps must be followed:

Enable Needed Integration Services:

This step involves activating the required integration services to ensure that the necessary API calls, security, and processing capabilities are available within Workday.

Configure Integration Field Attributes:

Integration Field Attributes allow customization of fields within the integration, enabling changes to formats, mappings, and transformations, such as including a dynamically generated file name with the current date and integration run number.

Configure Integration Maps:

Integration Maps are used to transform internal values into external values as per the vendor’s requirements. This ensures that data fields in Workday align correctly with external system specifications.

Configure Sequence Generator:

The Sequence Generator is used to append unique identifiers to output files, ensuring each integration run produces a uniquely named file (e.g., including the current date and run number).

This workflow ensures that the integration is set up efficiently while meeting the vendor’s additional configuration needs.

References:Workday Advanced Business Process documentation