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.