The Type Ahead Block in OmniScript functions as a container. For it to automatically populate other input fields (like Text elements for FirstName, LastName, and BirthDate) with data from a user's selection, those fields must be placed inside the Type Ahead Block in the OmniScript structure. This creates a parent-child relationship, enabling the block to pass the selected record's data to its child elements. If the fields are outside the block, they are not within its data scope and will not be updated upon selection.

A. The Type Ahead Block is a lookup component by nature; it does not have a specific "Lookup Mode" property that needs to be enabled for this functionality.

B. The "Use Data JSON" property is used to pre-fill the OmniScript with existing data when it loads, not to populate fields after a user makes a selection.

D. The Typeahead Key defines which field from the data source is displayed in the selection list. Since the user can see and select a contact, this key is configured correctly.

---

1. Salesforce OmniStudio Developer Guide:

Section: Type Ahead Block

Content: The documentation explicitly states

"To populate other controls with data from the Type Ahead

drag the controls into the Type Ahead Block. For example

to populate Address fields from a selected Account

drag Text controls for Street

City

State

and Postal Code into the Type Ahead Block." This directly confirms that child elements are required for data population.

2. Salesforce Trailhead:

Module: OmniScript

Unit: Build an OmniScript with the OmniScript Designer

Content: The "Add a Type Ahead block" section demonstrates the correct procedure: "To add fields that are populated by the Type Ahead

drag elements from the Build panel into the Type Ahead block." This reinforces the principle that target fields must be nested within the block.

In OmniStudio Integration Procedures, merge codes are used to reference data from the procedure's data JSON within element properties, such as an HTTP Action's URL. The syntax for these merge codes is %Node%. To access nested data within a JSON object, dot notation is used. The syntax %SetValues.Date% correctly references a Date node that exists within a SetValues JSON object at the root of the data tree. This is a common design pattern where the output of a step is namespaced under a parent node to prevent data conflicts.

A. t 'SetValues' ] [ 'Date' ]: This is not a valid merge code syntax in Salesforce or OmniStudio. It resembles incorrect JavaScript or JSON path notation.

B. {{SetValues.Date}}: This double curly brace syntax is used for data binding in other frameworks, such as Lightning Web Components or Handlebars.js, not for Integration Procedure merge fields.

D. %SetValues: Date%: The colon syntax (%ElementName:Node%) is used to reference the direct, unfiltered output of a specific element by its name. While a valid syntax, the dot notation is the standard for navigating the final, merged data JSON tree, which is the more common scenario implied by the question's structure.

1. Salesforce OmniStudio Developer Guide

"Access Data in the Data JSON". The guide specifies the use of merge fields with percent signs (%...%) to access data. It explicitly states

"To access a nested value

use dot notation." This supports the %ParentNode.ChildNode% structure. For example

to access a City node within an Address node

the syntax would be %Address.City%. This directly validates the structure used in option C.

2. Salesforce OmniStudio Developer Guide

"Integration Procedure Actions". In the section for the HTTP Action

the documentation shows examples of parameterizing the URL and other fields using merge codes. It reinforces that data from the JSON is accessed via the %...% syntax.

When an OmniScript fails to display data returned from an Integration Procedure, the issue often lies in how the data is processed and mapped after the Integration Procedure completes its execution.

1. The Response JSON Path property within the OmniScript's Integration Procedure Action element filters the raw JSON response. If this path is configured incorrectly or is too specific, it can exclude, or "trim," the nodes containing the expected data, preventing them from being added to the OmniScript's data JSON.

2. For data to be displayed in an OmniScript element (e.g., a Text Block), the element's Name property must exactly match the corresponding key (node name) in the JSON data structure. If the element name and the JSON key do not match, the data binding fails, and the data will appear to be missing.

C. The Integration Procedure Preview Input Parameters are used exclusively for testing the Integration Procedure in isolation within the designer and have no effect on its runtime execution when called from an OmniScript.

D. This option describes a potential issue with the input sent to the Integration Procedure. The problem described is with the response data being displayed in the OmniScript, which is a separate part of the data flow.

1. Salesforce OmniStudio Documentation

Integration Procedure Action: "To filter the response from the Integration Procedure

enter a path to a node in the Response JSON Path field. The data from the node is merged into the OmniScript's data JSON." This confirms that an incorrect path can trim data (Option A).

2. Salesforce OmniStudio Documentation

OmniScript Data JSON: "OmniScript elements display and update data in the OmniScript's data JSON. The Name of an element must match a key in the data JSON for the element to populate with data." This supports the reasoning for Option B.

3. Salesforce OmniStudio Documentation

Test an Integration Procedure: "The Preview tab enables you to test the Integration Procedure by providing input parameters and viewing the output... This is for design-time testing." This confirms that preview parameters do not affect runtime calls

making Option C incorrect.

The OmniScript element BlkContacts is configured as a Repeat Block. A Repeat Block is designed to iterate over a list of items and requires its input data to be a JSON array. The name of the JSON node containing the array must match the name of the Repeat Block element. Option A provides the correct structure: a root JSON object with a key named BlkContacts, whose value is an array of objects ([...]). Each object inside the array contains the key-value pairs that directly map to the input elements (FirstName, LastName, etc.) within the BlkContacts block, enabling the OmniScript to populate the fields correctly.

B: The BlkContacts node is a single JSON object, not an array. A Repeat Block cannot iterate over a single object and requires an array structure.

C: This JSON structure is a flat object and completely lacks the required BlkContacts parent node, so the OmniScript cannot find the data for the block.

D: The root of the JSON is an array, and the BlkContacts node is nested inside it. The OmniScript expects a root object with a BlkContacts array, not this nested structure.

1. Salesforce Help

OmniStudio Documentation

"Pass Data to an OmniScript": This document explicitly states

"To pass a list of items into an OmniScript

the JSON must have a node that is an array... The OmniScript element that receives the data must have the same name as the array node." This directly validates that a Repeat Block named BlkContacts requires a JSON structure of {"BlkContacts": [...]}.

2. Salesforce Help

OmniStudio Documentation

"OmniScript Block Element": In the properties table for the Block element

the "Repeat" checkbox description clarifies that enabling it "repeats the Block for each item in an array." This confirms the fundamental requirement of an array for the Repeat Block functionality.

3. Trailhead

OmniStudio Documentation

"OmniScript Data JSON": This module provides examples of the data structure OmniScripts expect. For repeatable blocks

the examples consistently show a named node that contains an array of objects

matching the structure in Option A. For instance

a repeatable block named Account would expect {"Account": [{"Name": "Acme"}

{"Name": "Global"}]}.

The Edit Block element is the ideal OmniScript component for this scenario as it is specifically designed to display and manage an array of sObjects, natively supporting add, edit, and delete functions for list items. To process the resulting data—which will be a mix of new, updated, and deleted records—a Remote Action is used. This action calls an Apex class method to handle the complex data manipulation language (DML) operations in a single, controlled server-side transaction, ensuring data integrity when saving the changes to the dependent records.

A Text Block element is used for displaying static, non-interactive text and cannot be used to capture or manage user input for a list of records.

An Input Block is a generic container for input fields but lacks the built-in functionality of an Edit Block to dynamically add, edit, and remove records from a list.

SOQL (Salesforce Object Query Language) is used for retrieving data, not for performing DML operations. An action element, not a SOQL statement, is required to save data.

1. Salesforce OmniStudio Documentation

Edit Block Element: "The Edit Block element enables a user to edit one or more fields in a list of sObjects... Edit Blocks support adding and deleting items from the array." This confirms the Edit Block is the correct UI element for managing a list.

2. Salesforce OmniStudio Documentation

Remote Action Element: "Call an Apex class and method from an OmniScript. Remote Actions are commonly used to save data to an sObject or perform other functions that are difficult to do with a DataRaptor." This supports using a Remote Action for the complex save logic required for a list of adds

edits

and deletes.

3. Salesforce OmniStudio Documentation

Text Block Element: "Display static instructional text in an OmniScript." This confirms it is not an input element.

Cloning an Integration Procedure creates an entirely new, independent procedure with its own unique Type and SubType. This new procedure has its own versioning lifecycle, starting at version 1. This action is appropriate when you need a new procedure that is structurally similar to an existing one but will be used for a different purpose, in a different context, or called independently. Versioning, in contrast, is used for iterative updates, enhancements, or bug fixes to the same logical procedure, where the new version replaces the old one upon activation.

A. The new Integration Procedure uses a Cache Block.

Adding a Cache Block is an enhancement. This type of modification is a standard use case for creating a new version of the existing procedure, not for cloning.

C. The new Integration Procedure is replacing stub data.

Replacing stub data with a live data source is a common iterative development step. This is a classic reason to create a new version of the same Integration Procedure.

D. The new Integration Procedure is Chainable.

Modifying the "Chainable" setting is a property change. This is handled by creating a new version of the procedure, not by creating a completely separate clone.

1. Salesforce Help

OmniStudio Documentation: Integration Procedures

Clone an Integration Procedure Version. The documentation states

"To create an Integration Procedure that's similar to an existing one

clone the existing one." This action results in a new procedure with its own name and version 1

confirming it is for creating a separate

independent asset.

2. Trailhead by Salesforce: Build Guided Experiences with OmniStudio Trail

Integration Procedures Module

Create and Version an Integration Procedure Unit. This unit explains

"When you clone an Integration Procedure

you create a new Integration Procedure with a new name (Type and Subtype) that has the same structure as the one you cloned. The new cloned Integration Procedure is version 1." This directly supports the concept of creating an independent procedure. In contrast

the same document describes versioning as creating a new iteration of the same procedure.

In an Integration Procedure, every Block you nest adds a JSON node around the elements it contains. A Response Action’s Send JSON Path must therefore traverse those nested nodes—using dot (.) notation—to reach the element whose output you want to return.

Given ActionZ is inside BlockY, which itself is inside BlockX, the correct traversal is:

BlockX.BlockY.ActionZ.

This is precisely the format shown in option A, and it is the only option that uses the required dot-separated JSON-path syntax.

B. ActionZ:BlockY:BlockX – Uses reverse order and colon separators; not valid JSON-path syntax in OmniStudio.

C. ActionZ:BlockY:BlockX – Same syntax problem as B and wrong hierarchical order.

D. BlockX:BlockY:ActionAZ – Uses colons, misspells ActionZ as “ActionAZ,” therefore invalid path.

1. Salesforce OmniStudio Developer Guide

“Response Action Element—Send JSON Path

” Winter ’24

§ Integration Procedures. Example path shown as “ParentBlock.ChildBlock.ActionName”.

2. Salesforce OmniStudio Implementation Guide

“Understand Integration Procedure JSON Structure

” Winter ’24

p. 13–14: explains dot-notation traversal of nested Blocks.

3. Salesforce Architects Blog

“Integration Procedure Best Practices

” 2023-03-07

para. ‘Return Only What You Need’: demonstrates Send JSON Path “AccountBlock.ContactBlock.GetContacts”.

To display a FlexCard on an Experience Cloud (Community) page, the standard and required method is to use the FlexCard Player component. This component is a standard Lightning Web Component that acts as a host or container for the FlexCard. Within the Experience Builder, the developer drags the FlexCard Player onto the page canvas. Then, in the component's property panel, the developer must specify the API name of the created FlexCard in the "FlexCard Name" attribute. This configuration links the player to the specific FlexCard, enabling it to be rendered on the page.

A. The FlexCard designer's "Card Configuration" section does not contain a "Deployment" property to target specific environments like a Community.

C. The "Publish Options" within the FlexCard designer are used for settings like custom permissions or OmniScript support, not for setting a deployment target like "CommunityPage".

D. Component Visibility is a standard feature in the Experience Builder to control which users can see a component; it is configured after the component is already on the page, not for the initial deployment of the FlexCard itself.

1. Salesforce Official Documentation

OmniStudio: Add a FlexCard to a Lightning or Experience Page. The documentation explicitly states: "To add a FlexCard to a Lightning or Experience page

add the FlexCard Player component to the page in the Lightning App Builder or Experience Builder. In the component's properties

enter the name of the FlexCard..." This directly supports the correct answer.

2. Salesforce Official Documentation

OmniStudio: FlexCards. Under the "Activate and Deploy FlexCards" section

the process described involves activating the card and then placing it on a page using the appropriate builder (Experience Builder for communities)

which utilizes the FlexCard Player component.

The "APEX CPU limit Exceeded" error indicates a server-side performance issue where the transaction is consuming too much processing time. The Action Debugger within the Integration Procedure's Preview is the primary tool for diagnosing such problems. It provides a detailed performance breakdown, showing the execution time in milliseconds for each step, including the calls to the DataRaptors. This allows the developer to pinpoint exactly which action is the bottleneck. Once the slow DataRaptor is identified, its DataRaptor configuration must be examined and optimized. This involves refining SOQL queries, reducing the number of fields retrieved, and simplifying formulas to decrease CPU usage.

A. Script configuration: This is too general. The error originates from the server-side Integration Procedure and DataRaptors, making their specific debugging tools more direct and effective.

B. Community logs: There is no specific logging tool named "Community logs" for this purpose. While general Apex debug logs exist, the Action Debugger is the specialized OmniStudio tool for this scenario.

1. Salesforce OmniStudio Documentation: Debug an Integration Procedure. The documentation explicitly details the use of the Action Debugger. It states

"The Action Debugger shows the data that is sent and received from each action in your Integration Procedure... and performance information

such as the execution time in milliseconds." This directly supports using the Action Debugger to identify performance bottlenecks.

2. Salesforce OmniStudio Documentation: DataRaptor Best Practices. This guide provides key recommendations for performance

such as

"To improve performance

select only the fields you need in a DataRaptor Extract." This confirms that reviewing and optimizing the DataRaptor configuration is a critical step in resolving CPU limit errors.

3. Trailhead by Salesforce: OmniStudio Integration Procedures

Unit: Test an Integration Procedure. This module illustrates how to use the Preview tab to test and debug. It highlights that the Action Debugger shows "the time the action took to run in milliseconds

" which is essential for troubleshooting performance issues like CPU timeouts.

A FlexCard displays data by binding its elements to the JSON data returned from its data source (e.g., a DataRaptor). Each field element uses a merge field, such as {FieldName}, to reference a specific key-value pair in the JSON. If the name used in the FlexCard element's merge field does not exactly match the corresponding key (JSON Path) in the output from the DataRaptor, the FlexCard cannot find the data to display. Consequently, only the field's label will be rendered, while other correctly mapped fields will show their data.

A. A misspelled {recordId} in the Data Source Input Map would cause the entire data source to fail, as it wouldn't receive the correct context. This would result in no data being displayed for any field.

C. A mismatch between the FlexCard field type and the Salesforce data type might cause formatting issues (e.g., a date appearing as a string), but it typically does not prevent the data from being rendered entirely.

D. Test Parameters are used only for previewing the FlexCard within the designer. Their absence or misconfiguration does not affect the FlexCard's behavior at runtime when it is activated and receives live data.

1. Salesforce OmniStudio Documentation

"Display Data on a FlexCard": This section details how to use merge fields to display data from a data source. It states

"To access a node

enter the node's name inside curly braces. For example

to access the Name node from a data source

enter {Name}." This highlights the direct name-matching requirement between the FlexCard element and the JSON data key.

2. Salesforce OmniStudio Documentation

"FlexCard Data Source Properties": This guide explains the role of the Input Map

including passing the recordId. It clarifies that this input is critical for the data source to fetch the correct record. An error here

as suggested in option A

would prevent the data source from returning any record-specific data.

3. Salesforce OmniStudio Documentation

"Preview a FlexCard with Test Parameters": This document explains that Test Parameters are used to "test your FlexCard's data source and layout" within the designer. This confirms that they are a design-time tool and their configuration does not impact the FlexCard's functionality in a live environment

making option D incorrect.