Workday-Pro-Integrations Sample Questions Answers

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.

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

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.

For Core Connector: Worker, selecting fields in Integration Field Attributes is not always enough if the related integration service is not enabled. Worker qualification information, including education-related data, is controlled by the Worker Qualification Data Section Fields Service. If that service is not enabled, the connector does not extract the section’s data, even when individual field attributes appear to be selected or the section is marked for output. Enabling every service is excessive and not the controlled configuration choice. Marking fields as required affects validation or required output behavior, but it does not activate the underlying qualification service. The correct fix is to enable the specific service that supplies the worker qualification data to the connector output.

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

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).

Predicated templates use XPath predicates inside square brackets to match only specific source nodes. The template must match the wd:Report_Entry node and then apply a predicate against the child value wd:Country_Code. Option A correctly creates three separate template matches: one for USA records, one for GBR records, and one fallback template for records where the country code is neither USA nor GBR. This is the cleanest XSLT pattern because each template processes a specific population of report entries. Options B and D incorrectly place the predicate or comparison after navigating directly to wd:Country_Code, which does not properly match the full report entry node. Option C combines USA and GBR in the first template and would not separate processing correctly.

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.

For recurring integration schedules, Workday limits how far into the future a recurrence can be scheduled. The maximum end date is tied to the next calendar year, not simply to the same month next year or the current year. Therefore, December 31st of the next calendar year is the correct maximum end date. This allows the integration to continue through the full next calendar year without requiring a shorter May-based cutoff. The current calendar year would end too soon for a monthly recurring schedule configured to continue beyond year-end. The second calendar year option extends too far and exceeds the normal scheduling limit. This question tests schedule governance, not transformation or report logic.

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

The required timestamp format is hour, minute, and second separated by colons. In the pattern token list, [h] represents the hour value, [m] represents minutes, and [s] represents seconds. Therefore, [h:m:s] is the correct pattern because it uses the correct time tokens and the correct colon separators. Option A and option D incorrectly use uppercase [M], which represents month, not minutes. Option C uses the correct hour, minute, and second tokens, but the separators are hyphens instead of colons, so it would not generate the requested timestamp format. Filename and sequence generator patterns are strict, so both token case and literal separators must match the required output exactly.

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

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.

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

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).

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.

The scenario involves a Core Connector: Candidate Outbound integration with the Data Initialization Service (DIS), where the vendor requires the " Country " field to be formatted differently (e.g., " United States of America " to " USA " ). This is a data transformation requirement, and Core Connectors provide specific tools to handle such formatting. Let’s evaluate the solution:

Requirement:The vendor needs a shortened country code (e.g., " USA " instead of " United States of America " ) in the output file. This involves transforming the delivered " Country " field value from the Candidate business object into a vendor-specific format.

Integration Maps:In Workday Core Connectors, integration maps are used to transform or map field values from Workday’s format to a vendor’s required format. For example, you can create a map that replaces " United States of America " with " USA, " " Canada " with " CAN, " etc. This is configured via the " Configure Integration Maps " related action on the integration system, allowing you to define a lookup table or rule-based transformation for the Country field.

Option Analysis:

A. Use an Evaluated Expression calculation and add it to the integration’s report data source: Incorrect. While an Evaluate Expression calculated field could transform the value (e.g., if-then logic), Core Connectors don’t directly use report data sources for output formatting. Calculated fields are better suited for custom reports or EIBs, not Core Connector field mapping.

B. Use the integration related action Configure Integration Population Eligibility: Incorrect. This action filters the population of candidates included (e.g., based on eligibility criteria), not the formatting of individual fields like Country.

C. Use the integration services to only output shortened country codes: Incorrect. Integration services define the dataset or events triggering the integration, not field-level formatting or transformations.

D. Use the integration related action Configure Integration Maps: Correct. Integration maps are the standard Core Connector tool for transforming field values (e.g., mapping " United States of America " to " USA " ) to meet vendor requirements.

Implementation:

Navigate to the Core Connector: Candidate Outbound integration system.

Use the related action Configure Integration Maps.

Create a new map for the " Country " field (e.g., Source Value: " United States of America, " Target Value: " USA " ).

Apply the map to the Country field in the integration output.

Test the output file to ensure the transformed value (e.g., " USA " ) appears correctly.

References from Workday Pro Integrations Study Guide:

Core Connectors & Document Transformation: Section on " Configuring Integration Maps " details how to transform field values for vendor-specific formatting.

Integration System Fundamentals: Explains how Core Connectors handle data transformation through maps rather than calculated fields or services for field-level changes.

Understanding the Requirement

The question involves scheduling an integration in Workday to deliver a file containing recent compensation changes to an external system. The key requirements are:

The file must be delivered routinely at 5 PM Eastern Standard Time (EST).

The recurrence should exclude weekends (i.e., run only on weekdays: Monday through Friday).

The file should include compensation changes since the last integration run, implying an incremental data pull, though this does not directly affect the recurrence type.

The task is to identify the correct recurrence type for the integration schedule from the given options:

A. Recurs every 12 hours

B. Recurs every weekday

C. Dependent recurrence

D. Recurs every 1 day(s)

Analysis of the Workflow and Recurrence Options

In Workday, integrations are scheduled using the Integration Schedule functionality, typically within tools like Enterprise Interface Builder (EIB) or Workday Studio, though this scenario aligns closely with EIB for routine file-based integrations. The recurrence type determines how frequently and under what conditions the integration runs. Let’s evaluate each option against the requirements:

Step-by-Step Breakdown

Time Specification (5 PM EST):

Workday allows scheduling integrations at a specific time of day (e.g., 5 PM EST). This is set in the schedule configuration and is independent of the recurrence type but confirms the need for a daily-based recurrence with a specific time slot.

Exclusion of Weekends:

The requirement explicitly states the integration should not run on weekends (Saturday and Sunday), meaning it should only execute on weekdays (Monday through Friday). This is a critical filter for choosing the recurrence type.

Incremental Data (Since Last Run):

The file must include compensation changes since the last integration run. In Workday, this is typically handled by configuring the integration (e.g., via a data source filter or " changed since " parameter in EIB), not the recurrence type. Thus, this requirement does not directly influence the recurrence type but confirms the integration runs periodically.

To upload an XSLT file to a Document Transformation integration system, you use the Configure Integration Attachment Service.

As per Workday documentation:

“The Configure Integration Attachment Service option on the Related Actions menu allows you to attach and manage XSLT files or other transformation documents used in Document Transformation integrations.”

This is the initial and correct method to upload the XSLT used for transforming incoming or outgoing XML.

Why the others are incorrect:

B. Configure Integration Attributes configures integration behavior, not attachments.

C and D reference invalid or misnamed tasks; they are not valid Workday tasks for XSLT upload.

When an integration is moved to an Integration System User, ownership must support unattended execution. The integration system itself can be owned by the ISU, but if an integration schedule exists, that schedule also needs to be owned by the ISU or transferred appropriately. Otherwise, the automated run can fail or continue to depend on the original human owner’s security context. Integration Maps, Integration Attributes, and Integration Field Attributes are configuration components inside the integration; they do not independently control scheduled execution ownership. The schedule is the object responsible for recurring automated launches, so it must align with the service account that owns and runs the integration. This is a security and operational control for stable Workday integration execution.

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

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.

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

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

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

Option Analysis:

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

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

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

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

Implementation:

Edit the Core Connector: Worker integration.

Navigate to the Integration Field Attributes section for the " Phone Number " field.

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

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

References from Workday Pro Integrations Study Guide:

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

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

The required filename needs a static prefix, runtime date tokens, and a monthly resetting sequence. The correct Workday-style pattern uses bracketed date tokens: [yyyy] for the four-digit year and [MM] for the two-digit month. The sequence token [seq] supplies the next sequence number. Because the sequence must be five digits, Padding must be set to 5 so values appear as 00001, 00002, and so on. Restart Frequency must be Month because the sequence resets at the beginning of each new month. Option B incorrectly treats the tokens as literal text and resets yearly. Option C uses invalid token names and resets daily. Option D uses nonstandard token names and lacks the required five-digit padding.

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

This question concerns a Full File test of a Core Connector: Worker integration where address fields (Address Line, Municipality, Region, Postal Code) are missing from the output, despite being configured in Configure Integration Field Attributes. Additionally, the Worker Personal Data Section is marked as Include in Output.

This issue commonly stems from a missed Enablement of the Address Data subfolder, which acts as a container for the address-related fields. Even if individual fields are selected, they will not appear in the output if their parent subfolder is not enabled.

From the Workday Pro Integrations documentation:

“Each subfolder in the integration field hierarchy, such as Address Data under Worker Personal Data, must be explicitly enabled. If the subfolder itself is not enabled, the fields within it, even if marked as Required or Included, will not be rendered in the output.”

To resolve this:

Navigate to Configure Integration Field Attributes

Expand the Worker Personal Data > Address Data subfolder

Enable the subfolder

Then reselect the required address fields

Incorrect Options Explained:

A. Mark each address field as RequiredMarking fields as Required is only effective if the parent subfolder is enabled. Without enabling the subfolder, fields remain excluded.

C. Enable the Worker Personal Data Section Fields integration serviceThis pertains to service execution, not field visibility. The issue lies in field hierarchy and inclusion, not the service configuration.

D. Enable All Services in Configure Integration ServicesThis enables all integration services but does not impact field inclusion or subfolder visibility within field attribute configuration.

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.

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 XSLT, the processor applies transformation rules by matching nodes using XPath expressions inside < xsl:template match= " " > statements.

“Templates define the rule, and XPath expressions determine which nodes they apply to.”

This is the foundational mechanism by which XSLT processes XML data.

Why the others are incorrect:

B. The < xsl:stylesheet > element defines scope, not node matching.

C. < xsl:call-template > invokes a named template but does not itself match nodes.

D. Namespace prefixes are used within XPath, but node matching is based on XPath.

In Workday integrations, XSLT (Extensible Stylesheet Language Transformations) is commonly used to transform XML data, such as the output from an Enterprise Interface Builder (EIB) or a web service-enabled report, into a format suitable for third-party systems. In this scenario, you are tasked with writing XSLT to process the wd:Dependents_Group elements within a report output to iterate only over those where the dependent relationship is " Child. " The correct XPath syntax for the select attribute of an < xsl:apply-templates > element is critical to ensure accurate data transformation.

Here’s why option B is correct:

XPath Syntax Explanation: In XPath, square brackets [ ] are used to specify predicates or conditions to filter elements. The condition wd:Relationship= ' Child ' checks if the wd:Relationship element (or attribute, depending on the XML structure) has the value " Child. " When applied to wd:Dependents_Group, the expression wd:Dependents_Group[wd:Relationship= ' Child ' ] selects only those wd:Dependents_Group elements that contain a wd:Relationship child element with the value " Child. "

Context in XSLT: Within an < xsl:apply-templates > element, the select attribute uses XPath to specify which nodes to process. This syntax ensures that the template only applies to wd:Dependents_Group elements where the dependent is a child, aligning with the requirement to conditionally process only those specific dependents.

XML Structure Alignment: Based on the provided XML snippet, wd:Dependents_Group likely contains child elements or attributes, including wd:Relationship. The correct XPath assumes wd:Relationship is an element (not an attribute), as is common in Workday XML structures. Therefore, wd:Dependents_Group[wd:Relationship= ' Child ' ] is the appropriate syntax to filter and iterate over the desired elements.

Why not the other options?

A. wd:Dependents_Group[@wd:Relationship= ' Child ' ]: This syntax uses @ to indicate that wd:Relationship is an attribute of wd:Dependents_Group, not an element. If wd:Relationship is not defined as an attribute in the XML (as is typical in Workday’s XML structure, where it’s often an element), this would result in no matches, making it incorrect.

C. wd:Dependents_Group/wd:Relationship= ' Child ' : This is not a valid XPath expression for a predicate. It attempts to navigate to wd:Relationship as a child but does not use square brackets [ ] to create a filtering condition. This would be interpreted as selecting wd:Relationship elements under wd:Dependents_Group, but it wouldn’t filter based on the value " Child " correctly within an < xsl:apply-templates > context.

D. wd:Dependents_Group/@wd:Relationship= ' Child ' : Similar to option A, this assumes wd:Relationship is an attribute, which may not match the XML structure. Additionally, it lacks the predicate structure [ ], making it invalid for filtering in this context.

To implement this in XSLT:

You would write an < xsl:apply-templates > element within your template matching wd:Report_Entry, with the select attribute set to wd:Dependents_Group[wd:Relationship= ' Child ' ]. This ensures that only wd:Dependents_Group elements with a wd:Relationship value of " Child " are processed by the corresponding templates, effectively filtering out other dependent relationships (e.g., Spouse, Parent) in the transformation.

This approach ensures the XSLT transformation aligns with Workday’s XML structure and integration requirements for processing worker data and dependents in an EIB or web service-enabled report.

Workday Pro Integrations Study Guide: Section on " XSLT Transformations for Workday Integrations " – Details the use of XPath in XSLT for filtering XML elements, including predicates for conditional processing.

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 XPath to navigate and filter data.

Workday Reporting and Analytics Guide: Section on " Web Service-Enabled Reports " – Covers integrating report outputs with XSLT for transformations, including examples of filtering elements based on values.

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.

Creating or associating a filename sequence generator is not enough by itself. The EIB must be configured so the File Name launch parameter determines its value at runtime from the sequence generator utility. The correct runtime field is Next Sequence for Integration File Utility. If the launch parameter is not set this way, Workday can still use a static or manually supplied filename, which means the configured sequence generator will not drive the final output filename. Typing the sequence generator name as a static value would not invoke the generator. The issue is also not simply a transformation problem or delivery endpoint problem. The key configuration gap is that the runtime filename value was not linked to the sequence generator output.

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

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.

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

The requirement is to filter a custom report to show only workers terminated after a user-prompted date. In Workday, filters are defined in the Filter tab of the custom report definition, and conditions can be combined using AND/OR logic to refine the dataset. Let’s analyze the requirement and options:

Key Conditions:

Workers must be terminated, so the " Worker Status " field must equal " Terminated. "

The termination must occur after a user-specified date, so the " Termination Date " must be greater than the prompted value.

Both conditions must be true for a worker to appear in the report, requiring an AND combination.

Option Analysis:

A. Worker Status is equal to the value " Terminated " OR Termination Date is greater than a value retrieved from a prompt: Incorrect. Using OR means the report would include workers who are terminated (regardless of date) OR workers with a termination date after the prompt (even if not terminated), which doesn’t meet the strict requirement of terminated workers after a specific date.

B. Worker Status is equal to the value retrieved from a prompt AND Termination Date is less than a value retrieved from a prompt: Incorrect. Worker Status shouldn’t be a prompted value (it’s fixed as " Terminated " ), and " less than " would show terminations before the date, not after.

C. Worker Status is equal to the value retrieved from a prompt OR Termination Date is equal to a value retrieved from a prompt: Incorrect. Worker Status shouldn’t be prompted, and " equal to " limits the filter to exact matches, not " after " the date. OR logic also broadens the scope incorrectly.

D. Worker Status is equal to the value " Terminated " AND Termination Date is greater than a value retrieved from a prompt: Correct. This ensures workers are terminated (fixed value) AND their termination date is after the user-entered date, precisely meeting the requirement.

Implementation:

In the custom report’s Filter tab, add two conditions:

Field: Worker Status, Operator: equals, Value: " Terminated " .

Field: Termination Date, Operator: greater than, Value: Prompt for Date (configured as a report prompt).

Set the logical operator between conditions to AND.

Test with a sample date to verify only terminated workers after that date appear.

References from Workday Pro Integrations Study Guide:

Workday Report Writer Fundamentals: Section on " Creating and Managing Filters " details combining conditions with AND/OR logic and using prompts.

Integration System Fundamentals: Notes how filtered reports support integration data sources with dynamic user inputs.

A valid XSLT file must include the following key components:

Root Element: < xsl:stylesheet > or < xsl:transform >

Namespace Declaration: Usually xmlns:xsl= " http://www.w3.org/1999/XSL/Transform "

At Least One < xsl:template > to define transformation behavior

From W3C and Workday documentation:

“A valid XSLT file must contain a stylesheet root element, a namespace, and at least one template to be considered executable.”

Why others are incorrect:

A. Prefix and header are not structural requirements.

B. " Transformation " is vague; it ' s the template that implements it.

C. Headers and footers are not required or defined elements in XSLT.