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

The scenario requires configuring a Core Connector: Candidate Outbound integration with the Data Initialization Service (DIS) to include only candidates who have undergone a candidate assessment event in Workday. Core Connectors are event-driven integrations that rely on business process transactions or specific data changes to trigger data extraction. Let’s analyze how to meet this requirement:

Understanding Core Connector and DIS:The Core Connector: Candidate Outbound integration extracts candidate data based on predefined services and events. The Data Initialization Service (DIS) ensures the initial dataset is populated, but ongoing updates depend on configured integration services that define which candidates to include based on specific events or conditions.

Candidate Assessment Event:In Workday, a "candidate assessment event" typically refers to a step in the recruiting business process where a candidate completes an assessment. The requirement to filter for candidates with this event suggests limiting the dataset to those who triggered an assessment-related transaction.

Integration Services:In Core Connectors, integration services determine the scope of data extracted by subscribing to specific business events or conditions. For this scenario, you can configure the integration services to monitor the "Candidate Assessment" event (or a related business process step) and include only candidates who have completed it. This is done by selecting or customizing the appropriate service within the Core Connector configuration to filter the candidate population.

Option Analysis:

A. Configure the integration services to only include candidates with assessments: Correct. This involves adjusting the integration services in the Core Connector to filter candidates based on the assessment event, ensuring only relevant candidates are included in the output file.

B. Set the integration transaction log to subscribe to specific transaction types: Incorrect. The integration transaction log tracks processed transactions for auditing but doesn’t control which candidates are included in the output. Subscription to events is handled via integration services, not the log.

C. Make the Candidate Assessment field required in integration field attributes: Incorrect. Integration field attributes define field-level properties (e.g., formatting or mapping), not the population of candidates included. Making a field "required" doesn’t filter the dataset.

D. Create an integration map to output values for candidates with assessments: Incorrect. Integration maps transform or map field values (e.g., converting "United States" to "USA") but don’t filter the population of candidates included in the extract. Filtering is a service-level configuration.

Implementation:

Edit the Core Connector: Candidate Outbound integration.

In the Integration Services section, select or configure a service tied to the "Candidate Assessment" event (e.g., a business process completion event).

Ensure the service filters the candidate population to those with an assessment event recorded.

Test the integration to verify only candidates with assessments are extracted.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on "Configuring Integration Services" explains how services define the data scope based on events or conditions.

Integration System Fundamentals

When creating a Date Difference calculated field in Workday, both dates must exist on the same business object. If they are on different business objects, you need to first bring the second date onto the primary object. To do that, you use a:

Lookup Related Value calculated field — this allows you to retrieve a field (like a date) from a related business object, so it can then be used in further calculations.

Example scenario:

You want to subtract Hire Date (on the Worker object) from Dependent’s Birth Date (on the Dependent object).

These are on different objects → use Lookup Related Value to pull the second date into the current object context.

Then, create the Date Difference using both dates on the same object.

Why other options are incorrect:

B. Build Date creates a synthetic date, not for bridging objects.

C. Lookup Date Rollup rolls up values across multiple related objects, not typically used for 1-to-1 value bridging.

D. Lookup Value as of Date is used for time-sensitive lookups (e.g., point-in-time values), not structural bridging.

In Workday integrations, XSLT is used to transform XML data, such as the output from an Enterprise Interface Builder (EIB) or a web service-enabled report, into a desired format for third-party systems. In this scenario, you need to write XSLT to process wd:Dependents_Group elements and output a relationship code based on the value of the wd:Relationship attribute or element. The requirement is to output "SP" for a "Spouse" relationship, "CH" for a "Child" relationship, and "OTHER" for any other relationship, using an statement within a template matching wd:Dependents_Group.

Here’s why option C is correct:

XSLT Structure: The element in XSLT provides conditional logic similar to a switch statement. It evaluates conditions in elements sequentially, executing the first matching condition, and uses for any case that doesn’t match.

Relationship as an Attribute: Based on the provided XML snippet, wd:Relationship is an attribute (e.g., Spouse within wd:Dependents_Group). However, in Workday XML for integrations, wd:Relationship is often represented as an attribute (@wd:Relationship) rather than a child element, especially in contexts like dependent data in reports. The syntax @wd:Relationship in the test attribute of correctly references this attribute, aligning with Workday’s typical XML structure for such data.

Condition Matching:

The first SP checks if the wd:Relationship attribute equals "Spouse" and outputs "SP" if true.

The second CH checks if the wd:Relationship attribute equals "Child" and outputs "CH" if true.

The OTHER handles all other cases, outputting "OTHER" if the relationship is neither "Spouse" nor "Child."

Context in Template: Since the template matches on wd:Dependents_Group, the test conditions operate on the current wd:Dependents_Group element and its attributes, ensuring the correct relationship code is output for each dependent. The XML snippet shows wd:Relationship as an element, but Workday documentation and integration practices often standardize it as an attribute in XSLT transformations, making @wd:Relationship appropriate.

Why not the other options?

A.

xml

WrapCopy

SP

CH

OTHER

This assumes wd:Relationship is a child element of wd:Dependents_Group, not an attribute. The XML snippet shows wd:Relationship as an element, but in Workday integrations, XSLT often expects attributes for efficiency and consistency, especially in report outputs. Using wd:Relationship without @ would not match the attribute-based structure commonly used, making it incorrect for this context.

B.

xml

WrapCopy

SP

CH

OTHER

This correctly uses @wd:Relationship for an attribute but has a logical flaw: if wd:Relationship='Child', the second would output "CH," but the order of conditions matters. However, the primary issue is that it doesn’t match the exact structure or intent as clearly as option C, and Workday documentation often specifies exact attribute-based conditions like those in option C.

D.

xml

WrapCopy

SP

CH

OTHER

This uses an absolute path (/wd:Relationship), which searches for a wd:Relationship element at the root of the XML document, not within the current wd:Dependents_Group context. This would not work correctly for processing dependents in the context of the template matching wd:Dependents_Group, making it incorrect.

To implement this in XSLT:

Within your template matching wd:Dependents_Group, you would include the statement from option C to evaluate the wd:Relationship attribute and output the appropriate relationship code ("SP," "CH," or "OTHER") based on its value. This ensures the transformation aligns with Workday’s XML structure and integration requirements for processing dependent data in an EIB or web service-enabled report, even though the provided XML shows wd:Relationship as an element—XSLT transformations often normalize to attributes for consistency.

Workday Pro Integrations Study Guide: Section on "XSLT Transformations for Workday Integrations" – Details the use of , , , and XPath for conditional logic in XSLT, including handling attributes like @wd:Relationship.

Workday EIB and Web Services Guide: Chapter on "XML and XSLT for Report Data" – Explains the structure of Workday XML (e.g., wd:Dependents_Group, @wd:Relationship) and how to use XSLT to transform dependent data, including attribute-based conditions.

Workday Reporting and Analytics Guide: Section on "Web Service-Enabled Reports" – Covers integrating report outputs with XSLT for transformations, including examples of conditional logic for relationship codes.

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.

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.

Whenever changes are made to domain security policies, they remain in a pending state until you explicitly activate them by running the:

Activate Pending Security Policy Changes task.

This ensures that all updates to permissions are applied across the tenant for real-time enforcement.

Why the others are incorrect:

A. Activate Previous Security Timestamp reverts to a prior configuration.

B. Activate All Pending Authentication Policy Changes is only for authentication rules.

D. Activate Metadata Schedule applies to metadata changes, not security.

When using Core Connector: Worker with DIS, to restrict the population to employees who:

Are on leave, and

Are located in San Francisco

You must configure Population Eligibility, which is the only place to filter the worker population included in the connector output.

From Workday Pro documentation:

“The Population Eligibility section defines which workers are eligible for extraction in the integration based on location, status, organization, and other conditions. Boolean calculated fields can be used here to define complex eligibility criteria.”

In this case:

Create a Boolean calculated field that returns true for “On Leave AND Location = San Francisco”

Use that field in Population Eligibility

Why the others are incorrect:

A, D. Field Overrides and Field Attributes only modify what data is extracted—not who is included.

C. Integration Attributes don’t control population filtering.

This scenario addresses an issue where a Core Connector: Worker integration — with DIS enabled and Full-Diff mode configured — unexpectedly includes terminated workers in the output, despite a requirement to include only active workers.

The correct step to address this issue is the configuration of Integration Population Eligibility.

From the Workday Pro: Integrations – Core Connector Configuration Guide, the relevant extract states:

“The Integration Population Eligibility step allows users to define which workers or populations are eligible to be included in the integration output. This includes filtering by worker status, organization, supervisory org, or other eligibility criteria. If this is not configured to exclude terminated workers, the integration will include all workers who meet the event conditions, regardless of their current status.”

Even though the integration uses change detection and the correct launch parameters, Workday still considers any worker with a qualifying change, including those terminated, unless they are explicitly excluded via eligibility rules.

Therefore, to prevent terminated workers from appearing in the output, you must set a filter in the Integration Population Eligibility step to include only active workers (e.g., using Worker.Status = Active or similar criteria).

Incorrect Options Explained:

A. Configure Integration Attributes... Include Inactive Workers in Full FileThis option would cause inactive (e.g., terminated) workers to be included when enabled. It doesn’t help filter them out.

B. Configure Integration Transaction Log... subscribe to everything except terminationSubscription controls which events trigger processing but does not control population eligibility. Terminated workers with address changes prior to termination could still appear if eligibility is not defined.

D. Configure Integration Field Overrides... use Eligibility CriterionField Overrides change data mappings or formats, not population eligibility. It cannot exclude terminated workers.

Overview

For an outbound Enterprise Interface Builder (EIB) in Workday, the option that uses a Workday-delivered transformation to output a format other than Workday XML is Alternate Output Format. This allows you to select formats like CSV, which Workday handles without needing custom coding.

How It Works

When setting up an outbound EIB, you can use a custom report as the data source. By choosing an alternate output format, such as CSV, Workday automatically transforms the data into that format. This is surprising because it simplifies the process, requiring no additional user effort for transformation.

Why Not the Others?

XSL Attachment Transformation (B): This requires you to provide your own XSL file, making it a custom transformation, not delivered by Workday.

Custom Transformation (C): This is clearly user-defined, not Workday-delivered.

Custom Report Transformation (D): This also involves user customization, typically through XSL, and isn't a pre-built Workday option.

Comprehensive Analysis

This section provides a detailed examination of Workday's Enterprise Interface Builder (EIB) transformation options, focusing on outbound integrations and the specific question of identifying the option that uses a Workday-delivered transformation to output a format other than Workday XML. We will explore the functionality, configuration, and implications of each option, ensuring a thorough understanding based on available documentation and resources.

Understanding Workday EIB and Outbound Integrations

Workday EIB is a no-code, graphical interface tool designed for both inbound and outbound integrations, facilitating the exchange of data between Workday and external systems. For outbound EIBs, the process involves extracting data from Workday (typically via a custom report) and delivering it to an external endpoint, such as via SFTP, email, or other protocols. The integration process consists of three key steps: Get Data, Transform, and Deliver.

Get Data: Specifies the data source, often a Workday custom report, which must be web service-enabled for EIB use.

Transform: Optionally transforms the data into a format suitable for the external system, using various transformation types.

Deliver: Defines the method and destination for sending the transformed data.

The question focuses on the Transform step, seeking an option that uses a Workday-delivered transformation to output a format other than Workday XML, which is typically the default format for Workday data exchanges.

Analyzing the Options

Let's evaluate each option provided in the question to determine which fits the criteria:

Alternate Output Format (A)

Description: This option is available when configuring the Get Data step, specifically when using a custom report as the data source. It allows selecting an alternate output format, such as CSV, Excel, or other supported formats, instead of the default Workday XML.

Functionality: When selected, Workday handles the transformation of the report data into the chosen format. For example, setting the alternate output format to CSV means the EIB will deliver a CSV file, and this transformation is performed by Workday without requiring the user to define additional transformation logic.

Workday-Delivered: Yes, as the transformation to the alternate format (e.g., CSV) is part of Workday's report generation capabilities, not requiring custom coding or user-provided files.

Output Format Other Than Workday XML: Yes, formats like CSV are distinct from Workday XML, fulfilling the requirement.

From resources like Workday HCM features | Workday EIB, it's noted that custom reports can use CSV as an alternate output format, and this is managed by Workday, supporting our conclusion.

XSL Attachment Transformation (B)

Description: This involves attaching an XSL (Extensible Stylesheet Language) file to the EIB for transforming the data, typically from XML to another format like CSV or a custom structure.

Functionality: The user must create or provide the XSL file, which defines how the data is transformed. This is used in the Transform step to manipulate the XML output from the Get Data step.

Workday-Delivered: No, as the XSL file is custom-created by the user. Resources like r/workday on Reddit: EIB xslt Transformation discuss users working on XSL transformations, indicating they are user-defined, not pre-built by Workday.

Output Format Other Than Workday XML: Yes, it can output formats like CSV, but it's not Workday-delivered, so it doesn't meet the criteria.

Custom Transformation (C)

Description: This option allows users to define their own transformation logic, often through scripting or other custom methods, to convert the data into the desired format.

Functionality: It is a user-defined transformation, typically used for complex scenarios where standard options are insufficient.

Workday-Delivered: No, as it explicitly states "custom," meaning it's not provided by Workday.

Output Format Other Than Workday XML: Yes, it can output various formats, but again, it's not Workday-delivered, so it doesn't fit.

Custom Report Transformation (D)

Description: This might refer to transformations specifically related to custom reports, potentially involving user-defined logic to manipulate the report data.

Functionality: From resources like Spark Databox - using custom report transformation, it involves using custom XSL transformations, indicating user involvement. It seems to be a subset of custom transformations, focusing on report data.

Workday-Delivered: No, as it involves custom XSL, which is user-provided, not pre-built by Workday.

Output Format Other Than Workday XML: Yes, it can output formats like pipe-delimited files, but it's not Workday-delivered, so it doesn't meet the criteria.

The scenario describes a Core Connector: Worker integration with specific configurations, and a test case where Jeff Gordon’s data doesn’t appear in the output despite an Edit Position event. Let’s analyze why Jeff Gordon is excluded and what needs to change:

Current Configuration:

Integration Field Attributes: Outputs Position Title and Business Title from Position Data.

Integration Population Eligibility: Filters workers where "Is Manager" = True (only managers).

Transaction Log Service: Subscribes to "Position Edit Event" transactions.

Launch Parameters:

As of Entry Moment: 05/25/2024 12:00:00 AM

Effective Date: 05/25/2024

Last Successful As of Entry Moment: 05/23/2024 12:00:00 AM

Last Successful Effective Date: 05/23/2024

Test Case:

Worker: Jeff Gordon (not a manager).

Action: Edit Position, updating Business Title.

Event Details: Effective Date 05/24/2024, Entry Moment 05/24/2024 07:58:53 AM.

Result: Jeff Gordon does not appear in the output.

Analysis:

Date Parameters: The integration captures changes between the Last Successful As of Entry Moment (05/23/2024 12:00:00 AM) and the current As of Entry Moment (05/25/2024 12:00:00 AM). Jeff’s Edit Position event (Entry Moment 05/24/2024 07:58:53 AM) falls within this range, and its Effective Date (05/24/2024) is before the integration’s Effective Date (05/25/2024), making it eligible from a date perspective.

Transaction Log: Subscribed to "Position Edit Event," which matches Jeff’s action (Edit Position), so the event type is correctly captured.

Field Attributes: Outputs Position Title and Business Title, and Jeff’s update to Business Title aligns with these fields.

Population Eligibility: Filters for "Is Manager" = True. Jeff Gordon is explicitly noted as "not assigned to the manager role," meaning "Is Manager" = False for him. This filter excludes Jeff from the population, regardless of the event or date eligibility.

Why Jeff is Excluded:The Integration Population Eligibility restriction ("Is Manager" = True) prevents Jeff Gordon from being included, as he isn’t a manager. This filter applies to the entire worker population before events or fields are considered, overriding other conditions.

Option Analysis:

A. Transaction Log Subscription: Incorrect. The subscription already includes "Position Edit Event," which matches Jeff’s action. Modifying this wouldn’t address the population filter.

B. Integration Population Eligibility: Correct. Changing this to include non-managers (e.g., removing the "Is Manager" = True filter or adjusting it to include all employees) would allow Jeff Gordon to appear in the output.

C. Date Launch Parameters: Incorrect. Jeff’s event (05/24/2024) falls within the date range, so the parameters are not the issue.

D. Integration Field Attributes: Incorrect. The attributes already include Business Title, which Jeff updated, so this configuration is irrelevant to his exclusion.

Modification Needed:Adjust the Integration Population Eligibility to either:

Remove the "Is Manager" = True filter to include all workers, or

Modify it to align with the scenario’s intent (e.g., "Worker Type equals Employee") if managers were an unintended restriction.

Implementation:

Edit the Core Connector: Worker integration.

Use the related action Configure Integration Population Eligibility.

Remove or adjust the "Is Manager" = True condition.

Relaunch the integration and verify Jeff Gordon appears in the output.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on "Configuring Integration Population Eligibility" explains how eligibility filters the worker population before event processing.

Integration System Fundamentals: Details how population scoping interacts with event subscriptions and launch parameters.

This question pertains to a Core Connector: Worker integration configured with Data Initialization Service (DIS) enabled and scheduled to run once daily. The integration is set to extract only those worker records where changes have occurred in compensation, home address, or business title since the last execution — leveraging Workday’s change detection to avoid full file extracts.

In testing, when a home address update occurs, the integration fails to capture this change in its output. However, all other components — such as worker eligibility, integration field attributes, and Full-Diff parameters — are confirmed to be correctly configured.

The critical element missing here is the event subscription. In Workday, for a Core Connector to recognize changes via Full-Diff or delta mode, it must be properly subscribed to the specific change events that should trigger inclusion in the output. This is done using the Edit Subscriptions configuration.

From the Workday Pro: Integrations documentation:

“The Edit Subscriptions task defines the set of data changes (e.g., job changes, address changes, compensation updates) that the integration system listens for. If an event type is not included in the subscription, changes related to that event will not be picked up in either delta or Full-Diff mode, regardless of other configuration.”

In this scenario, although the integration is configured for Full-Diff, failure to include "Home Address Change" in the subscription list prevents the system from recognizing the update, thereby omitting it from the output file.

Incorrect Options Explained:

A. Configure Integration Field OverridesThis option is used to override or map integration field values but has no impact on whether a change is detected or included in the output.

B. Maintain Integration AttributesWhile this configuration manages connector behavior and filtering rules, it does not control the detection of specific event changes.

D. Configure Integration Transaction LogThis is used for tracking and audit purposes but does not affect change detection or output inclusion.

The requirement is to create a calculated field for a dashboard that displays a worker’s name and the number of days until their next birthday in the format "[Worker's Name]'s birthday is in [X] days" (e.g., "Logan McNeil's birthday is in 103 days"). This involves calculating the difference between today’s date and the worker’s next birthday, then formatting the output as a text string. Let’s break down the necessary functions:

Date Difference:To calculate the number of days until the worker’s next birthday, you need to determine the difference between the current date and the worker’s birthdate in the current or next year (whichever is upcoming). The Date Difference function calculates the number of days between two dates. In this case:

Use the worker’s "Date of Birth" field (from the Worker business object).

Adjust the year of the birthdate to the current year or next year (if the birthday has already passed this year) using additional logic.

Calculate the difference from today’s date to this adjusted birthday date. For example, if today is February 21, 2025, and Logan’s birthday is June 4 (adjusted to June 4, 2025), Date Difference returns 103 days.

Format Number:The result of Date Difference is a numeric value (e.g., 103). To ensure it displays cleanly in the output string (without decimals or unnecessary formatting), Format Number can be used to convert it to a simple integer string (e.g., "103").

Text Constant:To build the output string, static text like "’s birthday is in " and " days" is needed. The Text Constant function provides fixed text values to include in the final concatenated result.

Concatenate Text:The final step is to combine the worker’s name (e.g., "Logan McNeil"), the static text, and the calculated days into one string. Concatenate Text merges multiple text values into a single output, such as "Logan McNeil" + "’s birthday is in " + "103" + " days".

Option Analysis:

A. Format Date, Increment or Decrement Date, Extract Single Instance, Format Text: Incorrect. Format Date converts dates to strings but doesn’t calculate differences. Increment or Decrement Date adjusts dates but isn’t suited for finding days until a future event. Extract Single Instance is for multi-instance fields, not relevant here. Format Text adjusts text appearance, not numeric calculations.

B. Build Date, Format Date, Extract Single Instance, Format Text: Incorrect. Build Date creates a date from components, useful for setting the next birthday, but lacks the difference calculation. Format Date and Extract Single Instance don’t apply to the core need.

C. Date Difference, Format Number, Text Constant, Concatenate Text: Correct. These functions cover calculating the days, formatting the number, adding static text, and building the final string.

D. Increment or Decrement Date, Format Number, Text Constant, Concatenate Text: Incorrect. Increment or Decrement Date can’t directly calculate days to a future birthday without additional complexity; Date Difference is more appropriate.

Implementation:

Use Date Difference to calculate days from today to the next birthday (adjusting the year dynamically with additional logic if needed).

Apply Format Number to ensure the result is a clean integer.

Use Text Constant for static text ("’s birthday is in " and " days").

Use Concatenate Text to combine Worker Name, static text, and the formatted number.

References from Workday Pro Integrations Study Guide:

Workday Calculated Fields: Section on "Date Functions" explains Date Difference for calculating time spans.

Report Writer Fundamentals: Covers Concatenate Text and Text Constant for string building in reports.

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.

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.

This question examines the limitations on assigning Integration System Users (ISUs) to integration systems in Workday Pro Integrations. Let’s analyze the relationship and evaluate each option to determine the correct answer.

Understanding ISUs and Integration Systems in Workday

Integration System User (ISU): An ISU is a specialized user account in Workday designed for integrations, functioning as a service account to authenticate and execute integration processes. ISUs are created using the "Create Integration System User" task and are typically configured with settings like disabling UI sessions and setting long session timeouts (e.g., 0 minutes) to prevent expiration during automated processes. ISUs are not human users but are instead programmatic accounts used for API calls, EIBs, Core Connectors, or other integration mechanisms.

Integration Systems: In Workday, an "integration system" refers to the configuration or setup of an integration, such as an External Integration Business (EIB), Core Connector, or custom integration via web services. Integration systems are defined to handle data exchange between Workday and external systems, and they require authentication, often via an ISU, to execute tasks like data retrieval, transformation, or posting.

Assigning ISUs to Integration Systems: ISUs are used to authenticate and authorize integration systems to interact with Workday. When configuring an integration system, you assign an ISU to provide the credentials needed for the integration to run. This assignment ensures that the integration can access Workday data and functionalities based on the security permissions granted to the ISU via its associated Integration System Security Group (ISSG).

Limitation on Assignment: Workday’s security model imposes restrictions to maintain control and auditability. Specifically, an ISU is designed to be tied to a single integration system to ensure clear accountability, prevent conflicts, and simplify security management. This limitation prevents an ISU from being reused across multiple unrelated integration systems, reducing the risk of unintended access or data leakage.

Evaluating Each Option

Let’s assess each option based on Workday’s integration and security practices:

Option A: An ISU can be assigned to five integration systems.

Analysis: This is incorrect. Workday does not impose a specific numerical limit like "five" for ISU assignments to integration systems. Instead, the limitation is more restrictive: an ISU is typically assigned to only one integration system to ensure focused security and accountability. Allowing an ISU to serve multiple systems could lead to confusion, overlapping permissions, or security risks, which Workday’s design avoids.

Why It Doesn’t Fit: There’s no documentation or standard practice in Workday Pro Integrations suggesting a limit of five integration systems per ISU. This option is arbitrary and inconsistent with Workday’s security model.

Option B: An ISU can be assigned to an unlimited number of integration systems.

Analysis: This is incorrect. Workday’s security best practices do not allow an ISU to be assigned to an unlimited number of integration systems. Allowing this would create security vulnerabilities, as an ISU’s permissions (via its ISSG) could be applied across multiple unrelated systems, potentially leading to unauthorized access or data conflicts. Workday enforces a one-to-one or tightly controlled relationship to maintain auditability and security.

Why It Doesn’t Fit: The principle of least privilege and clear accountability in Workday integrations requires limiting an ISU’s scope, not allowing unlimited assignments.

Option C: An ISU can be assigned to only one integration system.

Analysis: This is correct. In Workday, an ISU is typically assigned to a single integration system to ensure that its credentials and permissions are tightly scoped. This aligns with Workday’s security model, where ISUs are created for specific integration purposes (e.g., an EIB, Core Connector, or web service integration). When configuring an integration system, you specify the ISU in the integration setup (e.g., under "Integration System Attributes" or "Authentication" settings), and it is not reused across multiple systems to prevent conflicts or unintended access. This limitation ensures traceability and security, as the ISU’s actions can be audited within the context of that single integration.

Why It Fits: Workday documentation and best practices, including training materials and community forums, emphasize that ISUs are dedicated to specific integrations. For example, when creating an EIB or Core Connector, you assign an ISU, and it is not shared across other integrations unless explicitly reconfigured, which is rare and discouraged for security reasons.

Option D: An ISU can only be assigned to an ISSG and not an integration system.

Analysis: This is incorrect. While ISUs are indeed assigned to ISSGs to inherit security permissions (as established in Question 26), they are also assigned to integration systems to provide authentication and authorization for executing integration tasks. The ISU’s role includes both: it belongs to an ISSG for permissions and is linked to an integration system for execution. Saying it can only be assigned to an ISSG and not an integration system misrepresents Workday’s design, as ISUs are explicitly configured in integration systems (e.g., EIB, Core Connector) to run processes.

Why It Doesn’t Fit: ISUs are integral to integration systems, providing credentials for API calls or data exchange. Excluding assignment to integration systems contradicts Workday’s integration framework.

Final Verification

The correct answer is Option C, as Workday limits an ISU to a single integration system to ensure security, accountability, and clarity in integration operations. This aligns with the principle of least privilege, where ISUs are scoped narrowly to avoid overexposure. For example, when setting up a Core Connector: Job Postings (as in Question 25), you assign an ISU specifically for that integration, not multiple ones, unless reconfiguring for a different purpose, which is atypical.

Supporting Documentation

The reasoning is based on Workday Pro Integrations security practices, including:

Workday Community documentation on creating and managing ISUs and integration systems.

Tutorials on configuring EIBs, Core Connectors, and web services, which show assigning ISUs to specific integrations (e.g., Workday Advanced Studio Tutorial).

Integration security overviews from implementation partners (e.g., NetIQ, Microsoft Learn, Reco.ai) emphasizing one ISU per integration for security.

Community discussions on Reddit and Workday forums reinforcing that ISUs are tied to single integrations for auditability (r/workday on Reddit).

This question addresses a troubleshooting scenario in Workday Pro Integrations, where a calculated field used as a field override in a Connector does not appear in the output, despite having a value. Let’s analyze the potential causes and evaluate each option.

Understanding Calculated Fields and Connectors in Workday

Calculated Fields: In Workday, calculated fields are custom fields created using Workday’s expression language to derive values based on other fields, conditions, or functions. They are often used in reports, integrations, and business processes to transform or aggregate data. Calculated fields can reference other fields (data sources) and require appropriate security permissions to access those underlying fields.

Field Override in Connectors: In a Core Connector or other integration system, a field override allows you to replace or supplement a default field with a custom value, such as a calculated field. This is configured in the integration’s mapping or transformation steps, ensuring the output includes the desired data. However, for the calculated field to appear in the output, it must be accessible, have a valid value, and be properly configured in the integration.

Issue: Calculated Field Not Appearing in Output: If the calculated field has a value but doesn’t appear in the Connector’s output, the issue likely relates to security, configuration, or access restrictions. The question assumes the field has a value, so we focus on permissions or setup errors rather than data issues.

Evaluating Each Option

Let’s assess each option based on Workday’s integration and security model:

Option A: Access not provided to calculated field data source.

Analysis: This is partially related but incorrect as the primary cause. Calculated fields often rely on underlying data sources (e.g., worker data, organization data) to compute their values. If access to the data source is restricted, the calculated field might not compute correctly or appear in the output. However, the question specifies the field has a value, implying the data source is accessible. The more specific issue is likely access to the individual fields within the calculated field’s expression, not just the broader data source.

Why It Doesn’t Fit: While data source access is important, it’s too general here. The calculated field’s value exists, suggesting the data source is accessible, but the problem lies in finer-grained permissions for the fields used in the calculation.

Option B: Access not provided to all fields in the calculated field.

Analysis: This is correct. Calculated fields in Workday are expressions that reference one or more fields (e.g., Worker_ID + Position_Title). For the calculated field to be used in a Connector’s output, the ISU (via its ISSG) must have access to all fields referenced in the calculation. If any field lacks "Get" or "View" permission in the relevant domain (e.g., Worker Data), the calculated field won’t appear in the output, even if it has a value. This is a common security issue in integrations, as ISSGs must be configured with domain access for every field involved.

Why It Fits: Workday’s security model requires granular permissions. For example, if a calculated field combines Worker_Name and Hire_Date, the ISU needs access to both fields’ domains. If Hire_Date is restricted, the calculated field fails to output, even with a value. This aligns with the scenario and is a frequent troubleshooting point in Workday Pro Integrations.

Option C: Access not provided to Connector calculated field web service.

Analysis: This is incorrect. There isn’t a specific "Connector calculated field web service" in Workday. Calculated fields are part of the integration’s configuration, not a separate web service. The web service operation used by the Connector (e.g., Get_Workers) must have permissions, but this relates to the overall integration, not the calculated field specifically. The issue here is field-level access, not a web service restriction.

Why It Doesn’t Fit: This option misinterprets Workday’s architecture. Calculated fields are configured within the integration, not as standalone web services, making this irrelevant to the problem.

Option D: Access not provided to all instances of calculated field.

Analysis: This is incorrect. The concept of "instances" typically applies to data records (e.g., all worker records), not calculated fields themselves. Calculated fields are expressions, not data instances, so there’s no need for "instance-level" access. The issue is about field-level permissions within the calculated field’s expression, not instances of the field. This option misunderstands Workday’s security model for calculated fields.

Why It Doesn’t Fit: Calculated fields don’t have "instances" requiring separate access; they depend on the fields they reference, making this option inaccurate.

Final Verification

The correct answer is Option B, as the calculated field’s absence in the output is likely due to the ISU lacking access to all fields referenced in the calculated field’s expression. For example, if the calculated field in a Core Connector: Worker Data combines Worker_ID and Department_Name, the ISSG must have "Get" access to both the Worker Data and Organization Data domains. If Department_Name is restricted, the calculated field won’t output, even with a value. This is a common security configuration issue in Workday integrations, addressed by reviewing and adjusting ISSG domain permissions.

This aligns with Workday’s security model, where granular permissions are required for all data elements, as seen in Questions 26 and 28. The assumption that the field has a value rules out data or configuration errors, focusing on security as the cause.

Supporting Documentation

The reasoning is based on:

Workday Community documentation on calculated fields, security domains, and integration mappings.

Tutorials on configuring Connectors and troubleshooting, such as Workday Advanced Studio Tutorial, highlighting field access issues.

Integration security guides from partners (e.g., NetIQ, Microsoft Learn, Reco.ai) detailing ISSG permissions for fields in calculated expressions.

Community discussions on Reddit and Workday forums on calculated field troubleshooting (r/workday on Reddit).

In Workday, for an Integration System User (ISU) to be selectable as a Custom Report Owner, the security group the ISU belongs to must have Modify access to custom reports.

From Workday’s security configuration principle:

An ISU does not appear as a valid report owner unless its security group has Modify permission in the Report/Task Permissions section of the Custom Report Creation domain security policy.

This is because report ownership requires write‑level access over custom report objects.

Therefore, you must update the Report/Task Permissions table to include the ISSG with Modify access.

Options B, C, and D are incorrect because View or Get/Put do not provide report ownership capabilities.

As an integration developer working with Workday, you are tasked with transforming the output of an Enterprise Interface Builder (EIB) that calls the Get_Job_Profiles web service operation. The provided XML shows the response from this operation, and you need to write XSLT to select the value of the element where the wd:type attribute equals "Job_Profile_ID." The root template of your XSLT matches on and applies templates to . Within this template, you use the element to extract the value. Let’s analyze the XML structure, the requirement, and each option to determine the correct XPath syntax.

Understanding the XML and Requirement

The XML snippet provided is a SOAP response from the Get_Job_Profiles web service operation in Workday, using the namespace xmlns:wd="urn:com.workday/bsvc" and version wd:version="v43.0". Key elements relevant to the question include:

The root element is .

It contains , which includes elements.

Within , there is , which contains multiple elements, each with a wd:type attribute:

1740d3eca2f2ed9b6174ca7d2ae88c8c

Senior_Benefits_Analyst

The task is to select the value of the element where wd:type="Job_Profile_ID" (e.g., "Senior_Benefits_Analyst") using XPath within an XSLT template that matches . The element outputs the value of the selected node, so you need the correct XPath path from the context to the specific element with the wd:type attribute value "Job_Profile_ID."

Analysis of Options

Let’s evaluate each option based on the XML structure and XPath syntax rules:

Option A: wd:Job_Profile_Reference/wd:ID/wd:type='Job_Profile_ID'

This XPath attempts to navigate from wd:Job_Profile_Reference to wd:ID, then to wd:type='Job_Profile_ID'. However, there are several issues:

wd:type='Job_Profile_ID' is not valid XPath syntax. In XPath, to filter based on an attribute value, you use the attribute selector [@attribute='value'], not a direct comparison like wd:type='Job_Profile_ID'.

wd:type is an attribute of , not a child element or node. This syntax would not select the element itself but would be interpreted as trying to match a nonexistent child node or property, resulting in an error or no match.

This option is incorrect because it misuses XPath syntax for attribute filtering.

Option B: wd:Job_Profile_Reference/wd:ID/@wd:type='Job_Profile_ID'

This XPath navigates to wd:Job_Profile_Reference/wd:ID and then selects the @wd:type attribute, comparing it to "Job_Profile_ID" with =@wd:type='Job_Profile_ID'. However:

The =@wd:type='Job_Profile_ID' syntax is invalid in XPath. To filter based on an attribute value, you use [@wd:type='Job_Profile_ID'] as a predicate, not an equality comparison in this form.

This XPath would select the wd:type attribute itself (e.g., the string "Job_Profile_ID"), not the value of the element. Since expects a node or element value, selecting an attribute directly would not yield the desired "Senior_Benefits_Analyst" value.

This option is incorrect due to the invalid syntax and inappropriate selection of the attribute instead of the element value.

Option C: wd:Job_Profile_Reference/wd:ID[@wd:type='Job_Profile_ID']

This XPath navigates from wd:Job_Profile_Reference to wd:ID and uses the predicate [@wd:type='Job_Profile_ID'] to filter for elements where the wd:type attribute equals "Job_Profile_ID."

In the XML, contains:

1740d3eca2f2ed9b6174ca7d2ae88c8c

Senior_Benefits_Analyst

The predicate [@wd:type='Job_Profile_ID'] selects the second element, whose value is "Senior_Benefits_Analyst."

Since the template matches , and is a direct child of , this path is correct:

→ → .

When used with , it outputs "Senior_Benefits_Analyst," fulfilling the requirement.

This option is correct because it uses proper XPath syntax for attribute-based filtering and selects the desired value.

Option D: wd:Job_Profile_Reference/wd:ID/[@wd:type='Job_Profile_ID']

This XPath is similar to Option C but includes an extra forward slash before the predicate: wd:ID/[@wd:type='Job_Profile_ID']. In XPath, predicates like [@attribute='value'] are used directly after the node name (e.g., wd:ID[@wd:type='Job_Profile_ID']), not separated by a slash. The extra slash is syntactically incorrect and would result in an error or no match, as it implies navigating to a child node that doesn’t exist.

This option is incorrect due to the invalid syntax.

Why Option C is Correct

Option C, wd:Job_Profile_Reference/wd:ID[@wd:type='Job_Profile_ID'], is the correct XPath syntax because:

It starts from the context node (as the template matches this element) and navigates to , using the predicate [@wd:type='Job_Profile_ID'] to filter for the element with wd:type="Job_Profile_ID".

It correctly selects the value "Senior_Benefits_Analyst," which is the content of the element where wd:type="Job_Profile_ID".

It uses standard XPath syntax for attribute-based filtering, aligning with Workday’s XSLT implementation for web service responses.

When used with , it outputs the required value, fulfilling the question’s requirement.

Practical Example in XSLT

Here’s how this might look in your XSLT:

This would output "Senior_Benefits_Analyst" for the element with wd:type="Job_Profile_ID" in the XML.

Verification with Workday Documentation

The Workday Pro Integrations Study Guide and SOAP API Reference (available via Workday Community) detail the structure of the Get_Job_Profiles response and how to use XPath in XSLT for transformations. The XML structure shows containing elements with wd:type attributes, and the guide emphasizes using predicates like [@wd:type='value'] to filter based on attributes. This is a standard practice for navigating Workday web service responses.

Workday Pro Integrations Study Guide References

Section: XSLT Transformations in EIBs – Describes using XSLT to transform web service responses, including selecting elements with XPath and attribute predicates.

Section: Workday Web Services – Details the Get_Job_Profiles operation and its XML output structure, including and with wd:type attributes.

Section: XPath Syntax – Explains how to use predicates like [@wd:type='Job_Profile_ID'] for attribute-based filtering in Workday XSLT.

Workday Community SOAP API Reference – Provides examples of XPath navigation for Workday web service responses, including attribute selection.

Option C is the verified answer, as it correctly selects the value with wd:type="Job_Profile_ID" using the appropriate XPath syntax within the template context.

In Workday integrations, Document Transformation (DT) using XSLT with Workday Transformation Toolkit (XTT) attributes is used to transform XML data, such as the output from a Core Connector or EIB, into a specific format for third-party systems. In this scenario, you need to transform the ps:Position_ID field within the ps:Position element to a fixed length of 10 characters, truncate the value if it exceeds 10 characters, and align the output to the left. The template must match the ps:Position element and apply these formatting rules using XTT attributes.

Here’s why option A is correct:

Template Matching: The correctly targets the ps:Position element in the XML, as shown in the provided snippet, ensuring the transformation applies to the appropriate node.

XTT Attributes:

xtt:fixedLength="10" specifies that the Pos_ID field should be formatted to a fixed length of 10 characters. If the ps:Position_ID value exceeds 10 characters, it will be truncated (by default, XTT truncates without raising an error unless explicitly configured otherwise), meeting the requirement to truncate if the value exceeds.

xtt:align="left" ensures that the output is left-aligned within the 10-character field, aligning with the requirement to align everything to the left.

XPath Selection: The correctly extracts the ps:Position_ID value (e.g., "P-00030") from the ps:Position_Data child element, as shown in the XML structure.

Output Structure: The ... structure ensures the transformed data is wrapped in meaningful tags for the target system, maintaining consistency with Workday integration practices.

Why not the other options?

B.

xml

WrapCopy

This applies xtt:align="left" to the xsl:template element instead of the Pos_ID element. XTT attributes like fixedLength and align must be applied directly to the element being formatted (Pos_ID), not the template itself, making this incorrect.

C.

xml

WrapCopy

This applies xtt:fixedLength="10" to the Position element and xtt:align="left" to Pos_ID. However, XTT attributes like fixedLength and align should be applied to the specific field being formatted (Pos_ID), not the parent element (Position). This misplacement makes it incorrect.

D.

xml

WrapCopy

This applies xtt:fixedLength="10" to the xsl:template element and xtt:align="left" to Pos_ID. Similar to option B, XTT attributes must be applied to the specific element (Pos_ID) being formatted, not the template itself, making this incorrect.

To implement this in XSLT for a Workday integration:

Use the template from option A to match ps:Position, apply xtt:fixedLength="10" and xtt:align="left" to the Pos_ID element, and extract the ps:Position_ID value using the correct XPath. This ensures the ps:Position_ID (e.g., "P-00030") is formatted to 10 characters, truncated if necessary, and left-aligned, meeting the integration file requirements.

Workday Pro Integrations Study Guide: Section on "Document Transformation (DT) and XTT" – Details the use of XTT attributes like fixedLength and align for formatting data in XSLT transformations, including truncation behavior.

Workday Core Connector and EIB Guide: Chapter on "XML Transformations" – Explains how to use XSLT templates with XTT attributes to transform position data, including fixed-length formatting and alignment.

Workday Integration System Fundamentals: Section on "XTT in Integrations" – Covers the application of XTT attributes to specific fields in XML for integration outputs, ensuring compliance with formatting requirements like length and alignment.

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.

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 like Workday Core Connectors or Workday Integrations.

The scenario describes a Core Connector: Worker integration configured to output specific fields (Position Title and Business Title) for workers who meet the Integration Population Eligibility criteria (Is Manager = true) and where the Transaction Log service is subscribed to the "Position Edit Event." The integration is launched with specific date parameters, and a test edit is made to Jared Ellis’ position, who is a manager. However, despite the edit being completed with an effective date of 05/24/2024 and an entry moment of 05/24/2024 07:58:53 AM, Jared does not appear in the output. Let’s analyze why and determine the correct configuration element to modify.

In Workday integrations, the Core Connector: Worker uses change detection mechanisms to identify and process updates based on the Transaction Log and date launch parameters. The Transaction Log service captures events such as the "Position Edit Event" and records them with an Effective Date (when the change takes effect) and an Entry Moment (when the change was entered into the system). The integration’s date launch parameters define the time window for which changes are retrieved:

As of Entry Moment: 05/25/2024 12:00:00 AM – This specifies the latest point in time for when changes were entered into Workday.

Effective Date: 05/25/2024 – This defines the date for which the changes are effective.

Last Successful As of Entry Moment: 05/23/2024 12:00:00 AM – This indicates the starting point for entry moments from the last successful run.

Last Successful Effective Date: 05/23/2024 – This indicates the starting point for effective dates from the last successful run.

For an incremental run (like this one, since "Last Successful" parameters are provided), Workday processes changes where the Entry Moment falls between the Last Successful As of Entry Moment (05/23/2024 12:00:00 AM) and the As of Entry Moment (05/25/2024 12:00:00 AM), and where the Effective Date falls between the Last Successful Effective Date (05/23/2024) and the Effective Date (05/25/2024).

Now, let’s evaluate Jared Ellis’ edit:

Entry Moment: 05/24/2024 07:58:53 AM – This falls within the range of 05/23/2024 12:00:00 AM to 05/25/2024 12:00:00 AM.

Effective Date: 05/24/2024 – This falls within the range of 05/23/2024 to 05/25/2024.

At first glance, Jared’s edit seems to fit the date parameter window. However, the issue lies in the time component of the date launch parameters. Workday interprets these parameters with precision down to the second. The As of Entry Moment is set to 05/25/2024 12:00:00 AM (midnight), which is the very start of May 25, 2024. Jared’s Entry Moment of 05/24/2024 07:58:53 AM is correctly within the range from 05/23/2024 12:00:00 AM to 05/25/2024 12:00:00 AM. However, the Transaction Log subscription to "Position Edit Event" relies on the change being fully processed and available in the log by the time the integration runs.

The integration might have run at a point where the effective date window or the subscription logic did not correctly capture the event due to a mismatch in how the Effective Date is evaluated against the Last Successful Effective Date. Specifically, if the integration only processes changes with an Effective Date strictly after the Last Successful Effective Date (05/23/2024) up to the Effective Date (05/25/2024), and the logic excludes changes effective exactly on 05/24/2024 due to a boundary condition or a timing issue in the transaction log, Jared’s change might not be picked up.

To resolve this, modifying the Date launch parameters is necessary. Adjusting the As of Entry Moment to a later time (e.g., 05/25/2024 11:59:59 PM) or ensuring the Effective Date range explicitly includes all changes effective on or after 05/23/2024 through 05/25/2024 would ensure Jared’s edit is captured. This adjustment aligns the time window to include all relevant transactions logged before the integration run.

Let’s evaluate the other options:

A. Integration Population Eligibility: This is set to "Is Manager = true," and Jared is a manager. This filter is working correctly and does not need modification.

B. Integration Field Attributes: These are configured to output Position Title and Business Title, and the edit was to the Job Profile (part of Position Data). The fields are appropriately configured, so this is not the issue.

D. Transaction Log Subscription: The subscription is set to "Position Edit Event," which matches Jared’s edit. The subscription type is correct, so no change is needed here.

Thus, the issue stems from the date launch parameters not fully encompassing the timing of Jared’s edit in the Transaction Log, making C. Date launch parameters the correct answer.

Workday Pro Integrations Study Guide References

Workday Integrations Study Guide: Core Connector: Worker – Section on "Change Detection Using Transaction Log" explains how Transaction Log subscriptions filter events based on date parameters.

Workday Integrations Study Guide: Launch Parameters – Details the role of "As of Entry Moment" and "Effective Date" in defining the scope of incremental runs.

Workday Integrations Study Guide: Incremental Processing – Describes how "Last Successful" parameters establish the baseline for detecting changes in subsequent runs.