Workday Workday-Pro-Integrations - Workday Pro Integrations Certification Exam

This is a validation requirement, not a fixed-width formatting requirement. The goal is to confirm that required XML elements are not empty and to raise custom error messages with a defined severity. Workday’s ETV attributes are used for this type of validation behavior. etv:required= " true " marks the value as mandatory, etv:severity= " error " defines the severity level, and etv:name provides the custom validation message name shown when the rule fails. XTT attributes are primarily used for text transformation and formatting, such as fixed length, alignment, padding, and truncation handling. The target attribute is not the correct severity control in this context. Therefore, the ETV required, severity, and name attributes are the correct configuration.

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

An outbound EIB is organized around three main configuration components: Get Data, Transform, and Deliver. The Get Data section uses one data source, commonly a custom report or another supported source. The Transform section applies one transformation, such as an XSLT transformation, when formatting is required. The Deliver section sends the output to one delivery endpoint, such as SFTP, email, or another supported transport. Multiple data sources or multiple delivery endpoints are not the standard three-part model for a basic outbound EIB. A web service call and sequence generator may be used in some integration scenarios, but they are not the three primary EIB components. Therefore, option A matches the EIB architecture.

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

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.

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

This question is about the correct order of Workday security assignment for integrations. Workday clearly specifies the security structure:

“You assign the ISU to the Integration System Security Group (ISSG).

Then you assign the ISSG to the domain security policies.”

This is because domain security policies apply to security groups, not directly to ISUs.

Correct Relationship Order:

Create ISU

Create/assign ISU to ISSG

Assign ISSG to the domain security policies (Get/Put/View)

That aligns exactly to option C.

An outbound Enterprise Interface Builder has three core configuration areas: Get Data, Transform, and Deliver. To reconfigure those components after the EIB already exists, the correct related action is taken from the Enterprise Interface object, not from the generic Integration System path. “Enterprise Interface > Edit” opens the EIB configuration where the data source, transformation, and delivery settings can be changed. “Integration System > Edit” is too generic and does not directly expose the guided EIB component configuration. “Configure Transformation” only addresses one part of the EIB and does not allow full reconfiguration of all three components. Changing an integration template is also incorrect because the task is editing an existing EIB, not changing its template.

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

To use a custom report as an integration data source, especially through Report-as-a-Service or an EIB-style extract, the report must be configured so Workday can expose its output in a structured service format. Enabling the report as a Web Service allows the report to be called externally or used by integration tools. The Namespace is required so the XML output has a defined structure and can be referenced properly. XML Aliases for fields, group column headings, and prompts are also required because they control the XML element names used in the integration output. Web service aliases and “linking fields” are not the correct required set. Without these report settings, the integration cannot reliably consume the report as a service-based data source.

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

The task involves processing the " Legal Name - First Name " field in Workday to meet a third-party vendor’s requirement of accepting only one-word first names. For workers with multiple names (e.g., " John Paul " ), separated by a single space, the logic must:

Extract the value before the space (e.g., " John " from " John Paul " ).

Count the characters in the extracted value.

Check if the character count is greater than 0.

Use the extracted value if the count is greater than 0; otherwise, use the original " Legal Name - First Name " field.

This logic is typically implemented in Workday using calculated fields within a custom report or integration (e.g., EIB or Studio). Let’s break down the required functions:

Substring Text:This function is needed to extract the portion of the " Legal Name - First Name " field before the space. In Workday, the Substring Text function allows you to specify a starting position (e.g., 1) and extract text up to a delimiter (e.g., a space). For example, Substring Text( " John Paul " , 1, Index of " " ) would return " John. "

Text Length:After extracting the substring (e.g., " John " ), the logic requires counting its characters to ensure it’s valid. The Text Length function returns the number of characters in a text string (e.g., Text Length( " John " ) = 4). This is critical for the condition check.

True/False Condition:The logic involves a conditional check: " Is the number of characters greater than 0? " The True/False Condition function evaluates this (e.g., Text Length(extracted value) > 0), returning True if the extracted value exists and False if it’s empty (e.g., if no space exists or extraction fails).

Evaluate Expression:This function implements the if-then-else logic: if the character count is greater than 0, use the extracted value (e.g., " John " ); otherwise, use the original " Legal Name - First Name " field (e.g., " John Paul " ). Evaluate Expression combines the True/False Condition with the output values.

Option Analysis:

A. Extract Single Instance, Text Length, Numeric Constant, True/False Condition: Incorrect. Extract Single Instance is used for multi-instance fields (e.g., selecting one dependent), not text parsing. Numeric Constant isn’t needed here, as no fixed number is involved.

B. Text Constant, Substring Text, Arithmetic Calculation, Evaluate Expression: Incorrect. Text Constant provides a fixed string (e.g., " abc " ), not dynamic extraction. Arithmetic Calculation isn’t required, as this is a text length check, not a numeric operation beyond comparison.

C. Format Text, Convert Text to Number, True/False Condition, Evaluate Expression: Incorrect. Format Text adjusts text appearance (e.g., capitalization), not extraction. Convert Text to Number isn’t needed, as Text Length already returns a number.

D. Substring Text, Text Length, True/False Condition, Evaluate Expression: Correct. These functions align perfectly with the requirements: extract the first name, count its length, check the condition, and choose the output.

Implementation:

Create a calculated field using Substring Text to extract text before the space.

Use Text Length to count characters in the extracted value.

Use True/False Condition to check if the length > 0.

Use Evaluate Expression to return the extracted value or the original field based on the condition.

References from Workday Pro Integrations Study Guide:

Workday Calculated Fields: Section on " Text Functions " details Substring Text and Text Length usage.

Integration System Fundamentals: Explains how calculated fields with conditions (True/False, Evaluate Expression) transform data for third-party systems.

Core Connectors & Document Transformation: Highlights text manipulation for outbound integration requirements.

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

Context:

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

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

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

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

Option Analysis:

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

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

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

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

Implementation:

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

In the Core Connector configuration, navigate to the Integration Field Overrides section.

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

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

References from Workday Pro Integrations Study Guide:

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

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

In Workday integrations, XSLT is used to transform XML data, such as the output from a web service-enabled report or EIB, into a desired format for third-party systems. In this scenario, you need to create an XSLT template that matches the wd:Education_Group element in the provided XML and transforms it to produce the degree data in the format shown in the Transformed_Record example. The goal is to output each degree (e.g., " California University MBA " and " Georgetown University B.S. " ) as a < Degree > element within a < Degrees > parent element.

Here’s why option A is correct:

Template Matching: The < xsl:template match= " wd:Education_Group " > correctly targets the wd:Education_Group element in the XML, which contains multiple wd:Education elements, each with a wd:Degree child, as shown in the XML snippet (e.g., < wd:Education > California University < /wd:Education > < wd:Degree > MBA < /wd:Degree > ).

Transformation Logic:

< Degree > creates the outer < Degree > element for each education group, matching the structure in the Transformed_Record example (e.g., < Degree > California University MBA < /Degree > ).

< xsl:copy > < xsl:value-of select= " * " / > < /xsl:copy > copies the content of the child elements (wd:Education and wd:Degree) and concatenates their values into a single string. The select= " * " targets all child elements of wd:Education_Group, and xsl:value-of outputs their text content (e.g., " California University " and " MBA " become " California University MBA " ).

This approach ensures that each wd:Education_Group is transformed into a single < Degree > element with the combined text of the wd:Education and wd:Degree values, matching the example output.

Context and Output: The template operates on each wd:Education_Group, producing the nested structure shown in the Transformed_Record (e.g., < Degrees > < Degree > California University MBA < /Degree > < Degree > Georgetown University B.S. < /Degree > < /Degrees > ), assuming a parent template or additional logic wraps the < Degree > elements in < Degrees > .

Why not the other options?

B.

xml

WrapCopy

< xsl:template match= " wd:Education_Group " >

< Degree >

< xsl:value-of select= " * " / >

< /Degree >

< /xsl:template >

This uses < xsl:value-of select= " * " / > without < xsl:copy > , which outputs the concatenated text of all child elements but does not preserve any XML structure or formatting. It would produce plain text (e.g., " California UniversityMBACalifornia UniversityB.S. " ) without the proper < Degree > tags, failing to match the structured output in the example.

C.

xml

WrapCopy

< xsl:template match= " wd:Education_Group " >

< Degree >

< xsl:copy select= " * " / >

< /Degree >

< /xsl:template >

This uses < xsl:copy select= " * " / > , but < xsl:copy > does not take a select attribute—it simply copies the current node. This would result in an invalid XSLT syntax and fail to produce the desired output, making it incorrect.

D.

xml

WrapCopy

< xsl:template match= " wd:Education_Group " >

< Degree >

< xsl:copy-of select= " * " / >

< /Degree >

< /xsl:template >

This uses < xsl:copy-of select= " * " / > , which copies all child nodes (e.g., wd:Education and wd:Degree) as-is, including their element structure, resulting in output like < Degree > < wd:Education > California University < /wd:Education > < wd:Degree > MBA < /wd:Degree > < /Degree > . This does not match the flattened, concatenated text format in the Transformed_Record example (e.g., < Degree > California University MBA < /Degree > ), making it incorrect.

To implement this in XSLT for a Workday integration:

Use the template from option A to match wd:Education_Group, apply < xsl:copy > < xsl:value-of select= " * " / > < /xsl:copy > to concatenate and output the wd:Education and wd:Degree values as a single < Degree > element. This ensures the transformation aligns with the Transformed_Record example, producing the required format for the integration output.

Workday Pro Integrations Study Guide: Section on " XSLT Transformations for Workday Integrations " – Details the use of < xsl:template > , < xsl:copy > , and < xsl:value-of > for transforming XML data, including handling grouped elements like wd:Education_Group.

Workday EIB and Web Services Guide: Chapter on " XML and XSLT for Report Data " – Explains the structure of Workday XML (e.g., wd:Education_Group, wd:Education, wd:Degree) and how to use XSLT to transform education data into a flattened format.

Workday Reporting and Analytics Guide: Section on " Web Service-Enabled Reports " – Covers integrating report outputs with XSLT for transformations, including examples of concatenating and restructuring data for third-party systems.