Free Plat-Dev-210 Practice Test Questions and Answers (2026)

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.

For performing calculations on each element of an array in an Integration Procedure, best practices emphasize performance and reusability. Both Calculation Procedures and Calculation Matrices are designed to handle complex logic and can process entire arrays in a single, optimized server call. A Calculation Action is used to invoke them. This approach is significantly more performant than iterating with a Loop Block, especially for large datasets. Encapsulating the logic in a separate Procedure or Matrix also makes it reusable and easier to maintain, aligning with modular design principles.

A. The List Action is used to manipulate the structure of a list (e.g., merge, sort, filter), not to perform calculations on its individual elements.

C. Using a Loop Block is not a best practice for processing arrays due to significant performance degradation and scalability issues compared to bulk-enabled actions.

1. Salesforce OmniStudio Developer Guide

"Calculation Action in Integration Procedures": This document details how the Calculation Action is used to call both Calculation Procedures and Calculation Matrices. It highlights their ability to accept lists as input for bulk processing. (Refer to the sections on Inputs for Calculation Procedures and Matrices).

2. Salesforce OmniStudio Developer Guide

"Loop Blocks in Integration Procedures": The official documentation explicitly warns about the performance implications of using Loop Blocks. It states

"For better performance

avoid using a Loop Block when you can use another action that performs the same task on a list." This confirms that loops are not a best practice for list processing.

3. Salesforce OmniStudio Developer Guide

"Calculation Procedures": This guide describes Calculation Procedures as the appropriate tool to "run a series of calculations." Their design for complex

multi-step logic makes them ideal for the scenario described in the question.

4. Salesforce OmniStudio Developer Guide

"Calculation Matrices": This resource explains that Calculation Matrices are lookup tables that can take inputs and return calculated outputs. They are highly efficient for rule-based calculations and can be invoked to process entire lists.

A DataRaptor Transform is specifically designed to manipulate and restructure data from one format to another. In the context of generating a PDF from an OmniScript, a document template requires data in a specific JSON structure. While a DataRaptor Extract retrieves the raw data from Salesforce, a DataRaptor Transform is used to map and convert that raw data into the precise format expected by the PDF template. This transformation process is what effectively "pre-populates" the template with the correct data before the document is rendered.

A. A SOQL Query: This is a query language used by a DataRaptor Extract to fetch data from Salesforce. It is not the OmniStudio tool that structures the data for the PDF.

B. A DataRaptor Load: This tool is used to write data back into Salesforce objects. Its function is to save or update records, not to retrieve or format data for a document.

C. A DataRaptor Extract: This tool retrieves data from Salesforce objects. While it provides the source data, it does not perform the necessary restructuring to match the PDF template's required format.

1. Salesforce Trailhead

OmniStudio DataRaptors Module

"Create a DataRaptor Transform to Map Data" Unit: "A DataRaptor Transform can convert and transform data from one format to another... For example

you can transform the data structure of a DataRaptor Extract output to the format required by a Vlocity Document Template."

2. Salesforce Help

OmniStudio Documentation

"DataRaptor Transform": "Use a DataRaptor Transform to transform JSON or XML input data. For example

you can transform the data structure of a DataRaptor Extract output to the format required by a Vlocity Document Template."

3. Salesforce Help

OmniStudio Documentation

"Document Template Data Mapping": This section details the process of mapping data to document templates

a process where DataRaptor Transforms are a key component for structuring the input JSON. It states

"You can use a DataRaptor Transform to map the data from the data source to the token format."

The Formula element is the best practice for this scenario as it is specifically designed to perform real-time, client-side calculations within an OmniScript step. It can evaluate functions like COUNTIF based on user input from other elements in the same step and display the result immediately without requiring a server roundtrip. This provides the instant feedback the user needs. The element's value updates dynamically as the user interacts with the OmniScript, fulfilling the requirement to display the output immediately in the current step.

A. Set Values element: This element is primarily used to manipulate the OmniScript's data JSON, often runs server-side by default, and is not designed for immediate UI display of a calculation's result.

C. Range element: This is a user input control, similar to a slider, used for selecting a value within a specified range. It does not execute functions or perform calculations.

1. Salesforce OmniStudio Documentation

"Formula Element": "Formula elements perform calculations in real time on the client side. The result of a calculation can be used in the OmniScript's data JSON. For example

a Formula element can calculate the sum of two Currency elements and display the result." This confirms its use for real-time

client-side calculations and display.

2. Salesforce OmniStudio Documentation

"OmniScript Functions Reference": The COUNTIF function is listed as a supported function that can be used within OmniScript elements like the Formula element to "count the number of items in a list that meet a specified criteria."

3. Salesforce OmniStudio Documentation

"Set Values Element": "The Set Values element enables you to set static values or values from a data source in the data JSON." This highlights its primary purpose as data manipulation

not immediate UI calculation and display.

During an Integration Procedure (IP) preview, any Action’s data is returned in the final Response only when either 1) a Response Action is present or 2) the Action itself has Add/Send Output to Response JSON set to true. The developer sees the DataRaptor output in the Debug Log (which always records intermediate data) but the Response pane is empty, so the DataRaptor output was not promoted to the Response. Because no Response Action is mentioned, the most direct cause is that the DataRaptor Extract Action’s “Add Response To Response JSON” (a.k.a. “Send Output to Response”) flag was left unchecked.

A. Preview displays the Response JSON automatically; it is fully viewable.

C. A Response Action is optional if “Add Response to Response JSON” is enabled; absence alone doesn’t empty the response.

D. Validity of AccountId is proven by the extracted data visible in the log.

1. Salesforce OmniStudio Developer Guide

“Integration Procedures > DataRaptor Extract Action Properties > Send Output to Response JSON

” Spring ’24

para 2 (“If not selected

the output will appear only in Debug; it is not returned in the Response.”).

2. Salesforce Help: “Best Practices for Integration Procedures

” section “Returning Data

” ID DOC-000366546

¶3 (2023).

3. Trailhead Module “OmniStudio DataRaptors

” unit “Extract Data

” sub-section “Send Output to Response

” step 3 (2022).

The Edit Block element is specifically designed in OmniScript to display and manage an array of data, such as a list of dependents. It provides the user interface for adding, editing, and deleting rows within the script. To persist these changes to the Salesforce database, a Remote Action element is used. The Remote Action calls a server-side Apex class method, which can be written to handle the complex Create, Read, Update, and Delete (CRUD) logic required for managing the dependent records. This combination provides a robust and scalable solution.

B. You cannot configure an Edit Block with SOQL statements to perform write operations (add, edit, delete); SOQL is a query language used for retrieving data.

C. An Input Block is a container for a static set of input fields and does not support the dynamic addition or deletion of repeating records required for managing dependents.

D. A Text Block is a display-only element for showing static text and cannot be used for user input or managing a list of records.

1. Salesforce Help

OmniStudio Documentation

"Edit Block Element": "The Edit Block element enables a user to edit a specified number of fields from a list of sObjects. Users can add and delete rows in an Edit Block." This confirms the Edit Block is the correct UI component for managing a list of records.

2. Salesforce Help

OmniStudio Documentation

"Remote Action Element": "Call an Apex class and method from an OmniScript... Use a Remote Action to call an Apex class that does not have to be exposed as a web service." This confirms the use of Remote Action for executing server-side business logic.

3. Salesforce Help

OmniStudio Documentation

"Input Block": "The Input Block element is a container for Input elements. Use an Input Block to group related Input elements." This highlights that it is for grouping static fields

not dynamic lists.

An Integration Procedure is designed to orchestrate multiple steps, including data retrieval, manipulation, and callouts. When a JSON response from an HTTP action needs to be converted to XML, the standard, declarative tool for this task is a DataRaptor Transform. DataRaptors are a core component of OmniStudio for data manipulation. A DataRaptor Transform is specifically designed to change the structure of data, and it explicitly supports converting a JSON input into a specified XML output format. This "clicks-not-code" approach is the most efficient and maintainable solution within the OmniStudio framework for this requirement.

A. Use a Remote Action that calls the XMLStreamReader class

XMLStreamReader is an Apex class used for parsing (reading) an existing XML document, not for generating (writing) one from a JSON source.

B. Use a Remote Action that calls the XMLStreamWriter class

While technically feasible to write custom Apex code using XMLStreamWriter, this is a programmatic solution. The platform provides a declarative tool (DataRaptor Transform) for this exact purpose, which is the preferred method.

D. Use a DataRaptor Extract and check the XML checkbox on the Output JSON Path.

A DataRaptor Extract is used to retrieve data from Salesforce objects. It is not designed to transform an existing in-memory JSON structure from a previous step (like an HTTP Action) into XML.

1. Salesforce Help

OmniStudio Documentation

"DataRaptor Transform Action": "Use a DataRaptor Transform Action to transform data. For example

you can transform the data structure of the output of a DataRaptor Extract Action or a REST API call to the required input format of a subsequent action." This confirms a DataRaptor Transform is the correct tool to use after an API call.

2. Salesforce Help

OmniStudio Documentation

"Transform JSON Input to XML Output": "A DataRaptor Transform can convert JSON input to XML output. In the Output tab

you select XML as the Output Type. You then map data from the input JSON to the output XML." This section explicitly details the exact functionality required by the question.

3. Trailhead

OmniStudio DataRaptors

"Transform Data with DataRaptors": This module explains the function of each DataRaptor type. The "DataRaptor Transform" unit states its purpose is to "convert data from one format to another

" including JSON-to-JSON

XML-to-JSON

and JSON-to-XML transformations.

Both OmniScript and Card Layouts (now known as FlexCards) that display a list of items require the input data to be a JSON array. Each element within the array should be a JSON object that represents a single item (e.g., a single card or a row in a repeating block). Option D provides a root-level JSON array [ { ... } ], which is the standard and most direct data structure for these components. This format allows the component to iterate through the elements and display them accordingly. Options A and B are single objects, not arrays, and are therefore incompatible with list-based components.

A: This is a nested JSON object, not an array. Card Layouts require an array to iterate over for creating multiple cards.

B: This is a single JSON object. It cannot be used to populate a list or a series of cards, as it is not an array.

C: This is a JSON object containing a named array. While a Card Layout can be configured to use a nested array, the root-level array (Option D) is the more direct and standard format.

1. Salesforce Help

OmniStudio Documentation

FlexCard Data Source Properties: "The data source for a FlexCard must be in the form of an array of records

such as the data returned from a SOQL query or a DataRaptor that extracts a list of records." This confirms the requirement for an array structure.

2. Salesforce Help

OmniStudio Documentation

DataRaptors

DataRaptor Transform Action JSON for an Array: The documentation provides examples showing that to create a list of items

the output JSON from a DataRaptor Transform should be structured as a JSON array

[{"key":"value"}]

which matches Option D.

3. Trailhead

OmniStudio FlexCards

Build a Basic FlexCard: In the "Create a DataRaptor to Get Weather Data" unit

the test response for the DataRaptor Extract is shown as a root-level array of account objects

reinforcing that this is the expected format for a FlexCard data source.

An Integration Procedure requires a Response Action to formally structure and send data back to the calling element. The scenario states that the debug log shows the DataRaptor successfully retrieved data, confirming the data exists within the procedure's internal data JSON during execution. The fact that the final response is empty indicates that no mechanism was configured to take this internal data and map it to the final output. The Response Action is the standard and required component for this purpose; its absence is the most direct and likely cause of an empty response.

A. The DataRaptor Action did not have the add response to Response JSON property set to true.

This property (correctly named "Add Response to Data JSON") controls if the step's output is added to the data JSON. While unchecking it would hide data from the final response, the fundamental cause of an empty response is the missing Response Action itself.

B. The Response cannot be previewed directly.

This is factually incorrect. The Preview tab in the Integration Procedure designer is the primary tool for testing execution and viewing the final response JSON.

D. The AccountId used for the preview is invalid.

This is contradicted by the evidence provided in the question, which states, "The developer sees the data extract by the DataRaptor in the Debug Log." Data extraction would fail with an invalid ID.

---

1. Salesforce OmniStudio Documentation

"Integration Procedure Actions

" Section: Response Action.

This official guide states

"An Integration Procedure must have a Response Action to return data to a tool or process. The Response Action must be the last action in the Integration Procedure." This directly supports the conclusion that a missing Response Action results in no data being returned.

2. Salesforce OmniStudio Documentation

"Integration Procedure Data JSON

" Section: How Data Flows.

This document explains that actions add their output to the main data JSON tree. The Response Action then reads from this tree to create the final

trimmed output. This clarifies that even if data exists internally (as seen in the debug log)

it is not sent as the response without a Response Action.

3. Salesforce OmniStudio Documentation

"DataRaptor Extract Action in an Integration Procedure

" Section: Action Properties.

The documentation details the "Add Response to Data JSON" property

confirming its role is to merge the DataRaptor's output into the IP's data JSON. This supports the reasoning that while this property is important for data flow

the Response Action is what governs the final output.

The most direct and efficient way to limit the number of records returned by a DataRaptor Extract is to use the LIMIT filter property within the 'Extract' step's configuration. This property directly translates to the LIMIT clause in the underlying SOQL query that the DataRaptor generates. By setting this value to '1', the developer instructs the database to stop searching and return only the very first record that matches the filter criteria, which is the intended and most performant solution.

A. A formula with a Filter function processes data after it has been extracted from the database, which is inefficient for limiting the initial query.

B. The Output Type (e.g., JSON) defines the format of the output data, not the quantity of records retrieved from the source sObject.

D. The primary configuration for limiting a query's result set resides within the DataRaptor itself, not in the properties of a calling Action.

1. Salesforce OmniStudio Documentation

DataRaptors

"DataRaptor Extract Tab": In the section describing the properties for an sObject in the Extract step

the LIMIT field is defined. The documentation states

"Limits the number of records returned. Equivalent to the SOQL LIMIT clause." This confirms that LIMIT is the designated feature for this purpose.

2. Salesforce OmniStudio Developer Guide

"Create a DataRaptor Extract": The guide details the steps for building a DataRaptor Extract. In the section covering the 'Extract' tab

it illustrates the use of filters

including ORDER BY and LIMIT

as the standard mechanism for controlling the data set returned by the SOQL query.

The provided JSON structure shows that Customer is an array (indicated by []) containing a single object. In OmniScript, to access data from a specific index within an array, the pipe (|) notation followed by a zero-based index number (n) is used. Since the desired ID is in the first object of the Customer array, the correct index is 0. The correct path to the data is therefore Details:Customer|0:ID. Option A correctly implements this |0 notation. While %% delimiters are typically for OmniScript variables and not standard data JSON nodes in a Text Block (which usually use %), it is the only option that correctly identifies the array element's index.

B. To %%Details:Customer|n:ID%

This is incorrect because n is a placeholder for the index number; a specific integer like 0 must be used to retrieve data.

C. To %%Details:Customer|1:ID%

This is incorrect because arrays in OmniScript are zero-indexed. Using index 1 would attempt to access the second element, which does not exist in the provided data JSON.

D. To $Details:Customer|0:ID$

This is incorrect because $ is not a valid delimiter for merge codes in OmniScript. The standard delimiter is the percentage sign (%).

1. Salesforce Help

OmniStudio Documentation

"Access Data in an Array": This document specifies the syntax for accessing array elements. It states

"To access a specific node in an array

use the syntax ArrayName|n

where n is the array index number. For example

to access the first instance of an array

use ArrayName|0." This confirms that |0 is the correct notation for the first element.

2. Salesforce Help

OmniStudio Documentation

"OmniScript Merge Codes and Functions": This guide details the use of merge codes. It consistently shows the %datanode% syntax for pulling data from the data JSON into elements like Text Blocks. This confirms that % is the standard delimiter

and by extension

$ is incorrect.

3. Salesforce Help

OmniStudio Documentation

"OmniScript Text Block Element": The documentation for this specific element provides examples for displaying data: "Display data from the data JSON by using merge codes (for example

%FirstName%)." This reinforces that single % is the standard for this context.