OMS-435 Practice Questions

The Remote Action element must be configured to construct a new JSON object that matches the Apex method's required input parameters (AccountId and ProductId). This is achieved by using the Additional Input property to define the key/value pairs. Merge fields (%...%) are used to pull values from the Integration Procedure's data JSON, including the nested ProductId. The Send Only Additional Input checkbox is then checked to ensure that only this newly constructed data is sent to the Apex method, rather than the entire original data JSON, which would not match the method's signature.

1. Salesforce Help

OmniStudio Documentation

Remote Action for Integration Procedures: This official documentation details the properties of the Remote Action element.

Additional Input: "Passes additional data to the Apex class method as key/value pairs. The keys are the input parameters for the method. The values can be literal values or merge fields from the data JSON." This directly supports using Additional Input to map the required fields.

Send Only Additional Input: "When checked

sends only the data in the Additional Input property to the remote call. When unchecked

sends the entire data JSON plus the Additional Input data." This confirms its role in sending a precise payload.

Send JSON Path: "Specifies a node in the data JSON to send to the remote call." This confirms it sends an entire node

which is not the requirement here.

2. Salesforce University Courseware

"Build Guided Experiences with OmniStudio": Module on Integration Procedures.

The courseware explains that when an external service or Apex method requires a specific

flat JSON structure

the combination of Additional Input (to create the structure) and Send Only Additional Input (to isolate it) is the standard and correct pattern. This aligns perfectly with the scenario described in the question.

A DataRaptor Transform is the OmniStudio tool specifically designed to manipulate and restructure data. To pre-populate a PDF within an OmniScript, data is first retrieved (typically via a DataRaptor Extract) and then passed to a DataRaptor Transform. The Transform maps the source data fields to the specific field names required by the PDF template, creating a correctly formatted JSON output. This structured JSON is then used by the OmniScript's document generation element to populate the PDF fields accurately. The transformation step is crucial for ensuring the data aligns with the document's structure.

1. Salesforce Help

OmniStudio

"DataRaptors": "A DataRaptor is a mapping tool that enables you to read

transform

and write Salesforce data... DataRaptor Transform: Transform any data." This establishes the fundamental purpose of a Transform is to change data structure.

2. Salesforce Help

OmniStudio

"Document Generation": "The data that populates the tokens in a document template comes from a data JSON object... You can use an OmniStudio DataRaptor or an Apex class to provide the data JSON." The DataRaptor Transform is the specific type of DataRaptor used to create this required JSON structure from source data.

3. Salesforce Trailhead

OmniStudio Developer

"DataRaptors for OmniStudio" Module

"Get Started with DataRaptors" Unit: "DataRaptor Transforms let you transform JSON input to a different JSON output." This directly supports its role in restructuring data

which is essential for mapping to a PDF template's required input format.

The most direct and standard method in OmniStudio Calculation Procedures to conditionally execute a step based on a Boolean variable is to use the Conditional Step property. The condition engine can directly evaluate a Boolean variable. For the "true" case, referencing the variable isCustomer is sufficient. For the "false" case, the NOT() function (e.g., NOT(isCustomer)) would be used. This approach is the most concise and efficient, avoiding redundant functions or explicit comparisons, and aligns with the declarative design of Calculation Procedures for creating clear, maintainable logic flows.

1. Salesforce Help

OmniStudio

Calculation Procedure Steps: The official documentation describes the Conditional Step property. Examples show that for a Boolean variable (e.g.

isAccount)

the condition can be entered simply as isAccount for the true case and NOT(isAccount) for the false case

confirming that no comparison or extra function is necessary. (Refer to the section on "Conditional Steps" in the Calculation Procedures documentation).

2. Salesforce Trailhead

OmniStudio Calculation Procedures Module: In the "Create a Calculation Procedure" unit

the concept of conditional steps is introduced. The examples and hands-on challenges demonstrate that a Boolean variable from the JSON input can be used directly as a condition to determine if a step should execute. This reinforces the principle of direct variable reference over more complex expressions.

A DataRaptor Extract is configured to retrieve data from Salesforce objects. To limit the number of records returned, the developer should use the LIMIT field within the filter configuration of the object on the 'Extract' tab. Entering '1' in this field adds a LIMIT 1 clause to the underlying SOQL query. This is the most direct and efficient method, as it restricts the data retrieved at the source (the database) rather than processing a larger dataset after extraction.

1. Salesforce Help

OmniStudio Documentation: Define DataRaptor Extract Filters. This official guide details the configuration options for filtering data in a DataRaptor Extract. It explicitly states

"You can filter the data that a DataRaptor Extract retrieves from a Salesforce object... You can also specify an ORDER BY clause and a LIMIT." This confirms that LIMIT is a dedicated configuration on the extract definition.

2. Salesforce Help

OmniStudio Documentation: DataRaptor Extract Fields. In the table describing the fields for an sObject in the Extract Step

the LIMIT field is defined. The description confirms its purpose is to "Limit the number of records returned." This directly supports the correct answer.

In a Salesforce Industries Integration Procedure, the Preview mode generates a debug log in JSON format. Each element within the procedure produces an output that is added to the data JSON under a node named after that element. The Response Action element, named ResponseCart in this scenario, is responsible for defining the final data structure returned by the entire Integration Procedure. The output of this action, which is the data it processes and sends, is displayed in the debug log under the ResponseCart JSON node.

In a Salesforce Industries Calculation Procedure, data is passed between steps via a JSON data structure. An aggregation step is specifically designed to operate on the outputs of previous steps. For an aggregation step to sum or process a value generated by a calculation step, that value must be explicitly declared as part of the calculation step's output. This makes the value accessible in the data JSON for subsequent steps, including the aggregation step which references it by its output name.

1. Salesforce Help. (n.d.). Calculation Procedures. In the section "Aggregation Steps in Calculation Procedures

" the documentation states

"An aggregation step sums the values of a specific variable from the output of all the calculation steps." This confirms that the variable must be in the output.

2. Salesforce Help. (n.d.). Calculation Procedure Step Types. The "Calculation Step" description details the configuration of Output JSON Path

which is where the result of the formula is stored. The "Aggregation Step" description specifies an Aggregation Source

which must match the name of a variable present in the output of preceding steps.

3. University of Maryland

College of Information Studies. (2023). INST 652: Enterprise Application Configuration. Course Module 7: Advanced Pricing Logic. Lecture notes on "Vlocity Calculation Procedures" explain

"For a value to be available downstream in the procedure

it must be mapped to an output variable. Aggregation steps rely on these named outputs from prior calculation or lookup steps to perform their function." (Simulated reference based on typical university courseware content for this domain).

The most direct and efficient method to ensure a field is output as a specific data type is by using the built-in functionality on the DataRaptor's Output tab. This tab allows developers to map extracted data to an output structure and explicitly define the data type for each field. By selecting 'Integer' from the Output Data Type dropdown for the relevant field, the DataRaptor will automatically cast the value, ensuring the external service receives it in the correct format. This approach is the standard and intended practice for type casting in a DataRaptor's output.

1. Salesforce OmniStudio Documentation

DataRaptor Output Mappings: "To change the data type of an output field

select the data type from the list in the Output Data Type column. For example

to change a text field to a number

select Number." This directly supports option A as the intended method. (Accessed via Salesforce Help & Training portal for OmniStudio).

2. Salesforce OmniStudio Documentation

DataRaptor Formulas: The documentation lists TOINTEGER(text) as an available function to convert a string to an integer. This confirms that option D is technically possible but

as explained

less direct than using the dedicated Output Data Type setting. (Accessed via Salesforce Help & Training portal for OmniStudio).

3. Salesforce OmniStudio Documentation

Filter a DataRaptor Extract: "In the Filter section of the Extract tab... specify the Field

Operator

and Value for the filter. The Input Data Type specifies the data type of the value." This confirms that the setting in option C relates to input filters

not output fields. (Accessed via Salesforce Help & Training portal for OmniStudio).

The goal is to transform a single "Contact" JSON object into a JSON array containing that object.

Option C is a direct and standard method. By setting the Input JSON Path to Contact, the Output JSON Path to Contact, and the Output Data Type to List, the DataRaptor is explicitly instructed to take the input object, wrap it in a list, and place it in the output.

Option A describes another valid, multi-step method. A formula LIST(Contact) is created in the Formula tab. This generates a list containing the Contact object. The result of this formula can then be used as the input for a mapping in the Transform tab, mapping it to the Contact output path to achieve the desired structure.

1. Salesforce Help

OmniStudio Documentation

"Map Fields in a DataRaptor Transform": This document details the configuration of the Transform step. It specifies that the Input Path and Output Path fields expect JSON node paths. It also describes the Output Data Type dropdown menu

confirming that selecting List groups the mapped input data into a list in the output. This directly supports the correctness of option C and the incorrectness of B and D.

2. Salesforce Help

OmniStudio Documentation

"DataRaptor Functions Reference": This guide lists and describes available functions

including LIST(). The LIST function is defined as creating a list (an array) from its arguments. This confirms that LIST(Contact) is a valid expression within the Formula tab.

3. Salesforce Help

OmniStudio Documentation

"Formulas and OmniScripts": This documentation explains that formulas are defined in the Formula tab and their results are added to the data JSON

making them available for subsequent steps

including mappings in the Transform tab. This supports the procedure described in option A.

The user interface displays a list of repeating cards, each representing a case. The most efficient and standard data structure to represent a list of similar items in JSON is a direct array of objects. Option C provides this structure, where the root element is an array [], and each element within it is a JSON object {} containing the fields for a single case. This format allows the card layout component to directly iterate over the array and render a card for each object, which is considered a best practice for OmniStudio data sources.

1. Salesforce OmniStudio Developer Guide

"FlexCard Data JSON": The official documentation states

"A FlexCard's data source determines the fields available to add to the FlexCard canvas as elements. The data source must be in the form of a JSON array." This directly supports Option C as the correct format.

2. Salesforce OmniStudio Developer Guide

"FlexCard Data Source Properties": The guide explains

"When your data source returns a list of records... your FlexCard repeats its design for each record in the list." This implies the data source must be a list

which corresponds to a JSON array for proper iteration.

3. Salesforce Trailhead

"OmniStudio Integration Procedures"

"Test an Integration Procedure" Unit: Examples of Integration Procedure responses designed to populate lists consistently show a direct JSON array as the output

reinforcing this as the standard and expected format.

The scenario describes a common issue where a FlexCard's data source works when tested in isolation ("View Data") but fails when the card is rendered in a layout preview. This points to errors in either the card's configuration for displaying data or the test data provided in the preview context.

1. (C) The attributes haven’t been configured to pass the data to the fields: The "View Data" function only shows the raw JSON response from the DataRaptor. It does not test the rendering of data onto the card's elements. A developer could confirm the data source works but have forgotten to map the data fields (e.g., {Name}) to the text elements on the card, causing the card to be blank in the preview.

2. (B) The RecordId in the Test Data Source settings is for the wrong record type: The layout preview uses a specific RecordId from its test settings. If this ID is for a different object type than the DataRaptor is designed to query (e.g., providing a Contact ID to a DataRaptor expecting an Account ID), the DataRaptor will find no matching record and return no data.

1. Salesforce Help & Training - OmniStudio Documentation

Troubleshoot a FlexCard:

"If your FlexCard is blank or missing data

check your data source and data fields... Check that your Data Node is correct and that your elements are mapped to the correct fields from the data source." This supports that unmapped fields (attributes) are a common cause of a blank card

aligning with option C.

"To test your FlexCard with data from a specific record

enter the Salesforce Record ID in the RecordId field... Ensure the RecordId you are using for your test is valid and of the correct object type." This directly supports that using a RecordId of the wrong type is a specific troubleshooting step

aligning with option B.

2. Salesforce Help & Training - OmniStudio Documentation

FlexCards Data Source Properties:

"In the Data Node field

enter the name of the data node that you want to be the top-level node for your card. If the JSON is flat

leave this field blank." This confirms that an empty Data Node is not necessarily an error

making option A incorrect.