Free Practice Questions for Workday Workday-Pro-Integrations Exam

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.

To surface a Calculated Field in a Core Connector: Worker (CCW) outbound, you use an Integration Field Override to substitute the connector’s default source with your calculated value. An integration map (Option A) is intended to translate or normalize code values (for example, mapping internal Worker Type codes to the vendor’s codes), not to replace the source of a field. Integration attributes (Option D) and integration field attributes (Option C) manage connector behavior and attributes, but they do not replace a field’s data source with a calculated field. Therefore, the correct method to “pull” a calculated field into the CCW output is an Integration Field Override (Option B).

Why the other elements in the scenario matter (and how they’re handled) — with exact extracts from your materials:

Mapping Worker Type to external codes → Integration Maps (supports, but not the asked action):Your deployment guides call out maintaining and using Integration System Maps for code translations. This is exactly where you’d map “Worker Type” to the external system’s codes, but it is not how you inject a calculated field into the payload.

“Maintenance of Integration System Maps”

“WORKDAY SETUP – NON STATIC MAPS” and “WORKDAY SETUP – STATIC MAPS” (table of contents for configuration of maps)

Filename requires timestamp/sequence number → Sequence Generator (supports the scenario):Your Time Tracking/PECI deployment guide explicitly includes a Sequence Generator configuration that’s used with certified connectors to build compliant, unique file names (often with timestamps and/or sequence numbers) before delivery.

“3.6 Sequence Generator” (configuration item for certified integrations used in file naming)

Transformation before delivery → Standard integration flow (transform then deliver):The same deployment materials describe document/file delivery mechanics (for example, SFTP), which occur after the integration produces/transforms the document. This supports the scenario requirement that transformation happens prior to transmission.

“4. FILE DELIVERY SERVICE … 4.4 SFTP Configuration” (document delivery occurs after the integration generates/transforms the output)

Security posture for integrations (context):For outbound/system users and secure delivery, the Workday Authentication & Security guide documents integration-appropriate authentication (e.g., X.509) and general integration security steps — relevant background for productionizing CCW but not directly affecting how to bring a calculated field into the payload.

“X509 Recommended for web services users and integrations that use an integration system user account.”

Putting it all together for the scenario:

Use Integration Field Override to point the CCW field to your Calculated Field for UPN → (Correct answer: B).

Use Integration Maps to translate Worker Type to the vendor’s codes (supports the mapping requirement).

Configure filename rules via Sequence Generator to include timestamp and sequence in the produced file name (supports the file-naming requirement).

Ensure the document transformation runs as part of the integration generation step and then deliver via SFTP (file delivery service).

References (Workday Pro: Integrations-aligned materials):

GPC_PECI_TimeTracking_DeploymentGuide_CloudPay.pdf — Sections “3.6 Sequence Generator” and “4. File Delivery Service” (delivery occurs after file generation/transform).

GPC_PECI_DeploymentGuide_CloudPay_2.9.pdf — Map configuration sections (“WORKDAY SETUP – NON STATIC MAPS”, “WORKDAY SETUP – STATIC MAPS”).

GPC_PECI_UserGuide_CloudPay_2.1.1.pdf — “Maintenance of Integration System Maps.”

Admin-Guide-Authentication-and-Security.pdf — Integration security notes, including X.509 recommendation for integrations.

This requirement is a classic calculated-field transformation for an outbound report-based integration. The first step is to use Substring Text to extract only the first three characters from the worker’s first name and the first three characters from the worker’s last name. After both substrings are produced, Concatenate Text joins those values into a single User ID string. Finally, Format Text is required to convert the combined result to lowercase so the output matches the Active Directory vendor standard. Evaluate Expression is not required because there is no conditional logic. Lookup Related Value is also inappropriate because the values are already available from worker name fields. Text Constant is not enough because the result must be dynamically built for each worker.

================

Population Eligibility controls which workers are included in the Core Connector output population. In this scenario, the Population Eligibility is configured to include all US workers, so the connector correctly outputs that entire eligible population. The Eligibility Criterion field does not replace Population Eligibility as the population filter. It can support eligibility-related logic, but it is not the correct place to enforce the final worker population restriction when the actual extract should include only Sales workers. To fix the output, the Sales organization condition must be moved into the Population Eligibility rule itself. Updating the criterion field or running a full file would not solve the problem because the population filter would still include all US workers. The integration population must be filtered at the source.

================

In Workday, a sequence generator is used to create unique, sequential identifiers for integration processes, such as Enterprise Interface Builders (EIBs). These identifiers are often needed to ensure data uniqueness or to meet external system requirements for tracking records. The question asks specifically about building a sequence generator for an EIB integration, so we need to identify the correct task based on Workday’s integration configuration framework.

Understanding Sequence Generators in Workday

A sequence generator in Workday generates sequential numbers or IDs based on predefined rules, such as starting number, increment, and format. These are commonly used in integrations to create unique identifiers for outbound or inbound data, ensuring consistency and compliance with external system requirements. For EIB integrations, sequence generators are typically configured as part of the integration setup to handle data sequencing or identifier generation.

Analyzing the Options

Let’s evaluate each option to determine which task is used to build a sequence generator for an EIB integration:

A. Put Sequence Generator Rule Configuration

Description: This option suggests configuring rules for a sequence generator, but " Put Sequence Generator Rule Configuration " is not a standard Workday task name or functionality. Workday uses specific nomenclature like " Create ID Definition/Sequence Generator " for sequence generator setup. This option seems vague or incorrect, as it doesn’t align with Workday’s documented tasks for sequence generators.

Why Not Correct?: It’s not a recognized Workday task, and sequence generator configuration is typically handled through a specific setup process, not a " put " or rule-based configuration in this context.

B. Create ID Definition/Sequence Generator

Description: This is a standard Workday task used to create and configure sequence generators. In Workday, you navigate to the " Create ID Definition/Sequence Generator " task under the Integrations or Setup domain to define a sequence generator. This task allows you to specify the starting number, increment, format (e.g., numeric, alphanumeric), and scope (e.g., tenant-wide or integration-specific). For EIB integrations, this task is used to generate unique IDs or sequences for data records.

Why Correct?: This task directly aligns with Workday’s documentation for setting up sequence generators, as outlined in integration guides. It’s the standard method for building a sequence generator for use in EIBs or other integrations.

C. Edit Tenant Setup - Integrations

Description: This task involves modifying broader tenant-level integration settings, such as enabling services, configuring security, or adjusting integration parameters. While sequence generators might be used within integrations, this task is too high-level and does not specifically address creating or configuring a sequence generator.

Why Not Correct?: It’s not granular enough for sequence generator setup; it focuses on tenant-wide integration configurations rather than the specific creation of a sequence generator.

D. Configure Integration Sequence Generator Service

Description: This option suggests configuring a service specifically for sequence generation within an integration. However, Workday does not use a task named " Configure Integration Sequence Generator Service. " Sequence generators are typically set up as ID definitions, not as standalone services. This option appears to be a misnomer or non-standard terminology.

Why Not Correct?: It’s not a recognized Workday task, and sequence generators are configured via " Create ID Definition/Sequence Generator, " not as a service configuration.

Conclusion

Based on Workday’s integration framework and documentation, the correct task for building a sequence generator for an EIB integration is B. Create ID Definition/Sequence Generator. This task allows you to define and configure the sequence generator with the necessary parameters (e.g., starting value, increment, format) for use in EIBs. This is a standard practice for ensuring unique identifiers in integrations, as described in Workday’s Pro Integrations training materials.

Surprising Insight

It’s interesting to note that Workday’s sequence generators are highly flexible, allowing customization for various use cases, such as generating employee IDs, transaction numbers, or integration-specific sequences. The simplicity of the " Create ID Definition/Sequence Generator " task makes it accessible even for non-technical users, which aligns with Workday’s no-code integration philosophy.

Key Citations

Workday Pro Integrations Study Guide, Module 3: EIB Configuration

Workday Integration Cloud Connect: Sequence Generators

Workday EIB and Sequence Generator Overview

Configuring Workday Integrations: ID Definitions

The requirement combines CSV output formatting with a required-value check for date fields. For Workday transformation formatting classes, XTT is the correct attribute family. xtt:class defines reusable transformation formatting rules, xtt:name names the class, and xtt:dateFormat controls the rendered date pattern. The required US format is MM/dd/yyyy, and the EU format is dd.MM.yyyy. xtt:required= " true " ensures the Entry Date has a value when the output is produced. ETV attributes are used for validation rules rather than transformation formatting classes in this context. The bracketed date tokens in options C and D do not match the required dateFormat style shown for these XTT classes. Therefore, option A is the correct configuration.

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 Overrides allow 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 the Integration Field Overrides section.

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.

This requirement is fixed-width formatting, so the Workday XTT attributes are the correct family of attributes. xtt:fixedLength= " 25 " enforces a 25-character output length. xtt:paddingCharacter= " * " defines the padding character. To pad on the left, the value must be right-aligned, so xtt:align= " right " is required. If the value exceeds the allowed length, xtt:reportTruncation= " warning " issues a warning rather than silently truncating or raising an error. The etv attributes are used for validation-style behavior, not fixed-width text formatting. maxLength is also not the same as fixedLength because it sets a maximum rather than enforcing a padded fixed-width output. Therefore, option A matches the required transformation behavior exactly.

================

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 < xsl:if > 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

< job_skill >

< xsl:value-of select= " wd:Hiring_Restrictions/wd:Job_Skills= ' HR ' " >

< xsl:text > HR Skills < /xsl:text >

< xsl:if/ >

< xsl:value-of select= " not(wd:Hiring_Restrictions/wd:Job_Skills= ' HR ' ) " >

< xsl:text > NON-HR Skills < /xsl:text >

< xsl:if/ >

< /job_skill >

Issues:

< xsl:value-of > is misused here. It outputs the result of the expression (e.g., " true " or " false " for a comparison), not the conditional text. The < xsl:text > 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.

< xsl:if/ > is malformed (self-closing without a test attribute) and misplaced.

Verdict: Incorrect syntax and logic.

Option B:

xml

< job_skill >

< xsl:value-of select= " contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' ) " >

< xsl:text > HR Skills < /xsl:text >

< xsl:if/ >

< xsl:value-of select= " not(contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' )) " >

< xsl:text > NON-HR Skills < /xsl:text >

< xsl:if/ >

< /job_skill >

Issues:

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

The < xsl:text > elements are inside invalid < xsl:if/ > tags (self-closing, no test), rendering them ineffective.

While contains() is correct for substring checking, the structure fails to meet the < xsl:if > requirement.

Verdict: Incorrect structure despite using contains().

Option C:

xml

< job_skill >

< xsl:if test= " wd:Hiring_Restrictions/wd:Job_Skills= ' HR ' " >

< xsl:text > HR Skills < /xsl:text >

< /xsl:if >

< xsl:if test= " not(wd:Hiring_Restrictions/wd:Job_Skills= ' HR ' ) " >

< xsl:text > NON-HR Skills < /xsl:text >

< /xsl:if >

< /job_skill >

Analysis:

Uses < xsl:if > correctly with test attributes, satisfying the " series of < xsl:if > 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

< job_skill >

< xsl:if test= " contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' ) " >

< xsl:text > HR Skills < /xsl:text >

< /xsl:if >

< xsl:if test= " not(contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' )) " >

< xsl:text > NON-HR Skills < /xsl:text >

< /xsl:if >

< /job_skill >

Analysis:

Correctly uses < xsl:if > 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).

< xsl:text > outputs the exact strings " HR Skills " or " NON-HR Skills " as required.

Note: The closing tag < /xs1:if > is a typo in the option (should be < /xsl:if > ), 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

< xsl:template match= " wd:Report_Data/wd:Report_Entry " >

< job_skill >

< xsl:if test= " contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' ) " >

< xsl:text > HR Skills < /xsl:text >

< /xsl:if >

< xsl:if test= " not(contains(wd:Hiring_Restrictions/wd:Job_Skills, ' HR ' )) " >

< xsl:text > NON-HR Skills < /xsl:text >

< /xsl:if >

< /job_skill >

< /xsl:template >

Example Input: < wd:Job_Skills > Senior HR Analyst < /wd:Job_Skills > → Output: < job_skill > HR Skills < /job_skill >

Example Input: < wd:Job_Skills > IT Specialist < /wd:Job_Skills > → Output: < job_skill > NON-HR Skills < /job_skill >

Workday Pro Integrations Study Guide: " Configure Integration System - TRANSFORMATION " section, detailing < xsl:if > 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 < xsl:if > , " and Section 11.2, " String Functions " (contains()).

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

In Workday reporting, selecting the appropriate Primary Business Object (PBO) and Related Business Objects (RBOs) is critical to ensure that the report retrieves and organizes data correctly based on the requirements. The requirement here is to create a report that outputs one row per worker for a specified supervisory organization, including their active benefit plans and the names and ages of all related dependents. The Worker business object contains fields like Employee, Benefit Plans, and Dependents, while the Dependent business object provides the Name and Age fields for dependents.

Why Worker as the PBO?The report needs to output " one row per worker, " making the Worker business object the natural choice for the PBO. In Workday, the PBO defines the primary dataset and determines the granularity of the report (i.e., one row per instance of the PBO). Since the report revolves around workers and their associated data (benefit plans and dependents), Worker is the starting point. Additionally, the requirement specifies a supervisory organization at runtime, which is a filter applied to the Worker business object to limit the population.

Why Dependent as an RBO?The Worker business object includes a " Dependents " field, which is a multi-instance field linking to the Dependent business object. To access detailed dependent data (Name and Age), the Dependent business object must be added as an RBO. This allows the report to pull in the related dependent information for each worker. Without the Dependent RBO, the report could only reference the existence of dependents, not their specific attributes like Name and Age.

Analysis of Benefit Plans:The Worker business object already contains the " Benefit Plans " field, which provides access to active benefit plan data. Since this is a field directly available on the PBO (Worker), no additional RBO is needed to retrieve benefit plan information.

Option Analysis:

A. PBO: Dependent, RBO: Worker: Incorrect. If Dependent were the PBO, the report would output one row per dependent, not one row per worker, which contradicts the requirement. Additionally, Worker as an RBO would unnecessarily complicate accessing worker-level data.

B. PBO: Worker, RBO: Dependent: Correct. This aligns with the requirement: Worker as the PBO ensures one row per worker, and Dependent as the RBO provides access to dependent details (Name and Age). Benefit Plans are already accessible via the Worker PBO.

C. PBO: Dependent, no RBOs: Incorrect. This would result in one row per dependent and would not allow easy access to worker or benefit plan data, failing to meet the " one row per worker " requirement.

D. PBO: Worker, no RBOs: Incorrect. While Worker as the PBO is appropriate, omitting the Dependent RBO prevents the report from retrieving dependent Name and Age fields, which are stored in the Dependent business object, not directly on Worker.

Implementation:

Create a custom report with Worker as the PBO.

Add a filter for the supervisory organization (specified at runtime) on the Worker PBO.

Add Dependent as an RBO to access Name and Age fields.

Include columns from Worker (e.g., Employee, Benefit Plans) and Dependent (e.g., Name, Age).

References from Workday Pro Integrations Study Guide:

Workday Report Writer Fundamentals: Section on " Selecting Primary and Related Business Objects " explains how the PBO determines the report’s row structure and RBOs extend data access to related objects.

Integration System Fundamentals: Discusses how multi-instance fields (e.g., Dependents on Worker) require RBOs to retrieve detailed attributes.