Free OMS-435 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

The goal is to configure the system to dynamically pass through the exact input data. The syntax {{input}} represents a variable or placeholder that references the entire incoming data object. This is a standard convention in many data integration and workflow automation platforms using templating engines like Handlebars or Mustache. By setting the "Additional input" to {{input}} and enabling "Send Only Additional input," the configuration ensures that for any given input, its complete data structure is dynamically used as the new payload. This approach is robust and works regardless of the specific content of the incoming data.

1. Handlebars.js Documentation: The {{...}} syntax is a core feature of templating engines like Handlebars. The documentation states

"A handlebars expression is a {{

some contents

followed by a }}." This syntax is used to embed and reference data objects within a template. In this context

{{input}} would reference the entire input object.

Source: Handlebars.js official documentation

"Expressions" section. (See: https://handlebarsjs.com/guide/#expressions)

2. n8n Documentation (Workflow Automation Platform): Modern workflow automation tools use this expression syntax to handle data. The n8n documentation explains how to reference incoming JSON data. For example

{{$json.body}} references the body of an incoming item. The variable {{input}} follows this exact principle for referencing the entire input data item.

Source: n8n Documentation

"Expressions

" section on "Data from other nodes." (See: https://docs.n8n.io/expressions/)

3. Postman Documentation (API Platform): The Postman API client extensively uses the {{variablename}} syntax to dynamically insert data into requests. This demonstrates the widespread

standard use of this notation for referencing data variables in technical configuration.

Source: Postman Learning Center

"Using variables

" section "Accessing variables in requests." (See: https://learning.postman.com/docs/sending-requests/variables/)

A FlexCard displays data by binding its elements to a data source, typically the JSON output from a DataRaptor. For a field to display a value, the Field property of the element on the FlexCard canvas must exactly match the corresponding key (JSON path name) in the data source's output JSON. If there is a mismatch for a single field (e.g., the DataRaptor outputs AcctName but the FlexCard element is mapped to AccountName), the FlexCard cannot locate the data for that specific element. As a result, only the element's label will be rendered, while other correctly mapped fields will display their data successfully.

1. Salesforce Help

OmniStudio Documentation

"Display Data on a FlexCard": This document explains the process of data binding. It specifies that to display data

you must drag a field element onto the canvas and in the properties

set the Field attribute to the name of the JSON node from the data source. This directly supports the conclusion that a name mismatch causes the display failure. (See section: Add Fields and Actions to a State).

2. Salesforce Trailhead

"OmniStudio FlexCards" Module

"Bind Data to a FlexCard" Unit: This module provides practical examples demonstrating that the Field property of a FlexCard element must be mapped to the exact name of the key in the JSON data structure provided by the DataRaptor. A failure to match these names results in the exact behavior described in the question.

3. Salesforce Help

OmniStudio Documentation

"FlexCard Data Source Properties": This resource details how data sources are configured. It shows that the Data Source Input Map (using {recordId}) provides context for the entire data retrieval operation. An error here

as suggested in option A

would impact the whole data set. (See section: Context Variables).

In Salesforce Industries Integration Procedures, merge fields are used to access data from the data JSON. To reference a specific JSON node from the output of a previous step, the correct syntax is %StepName:JSONNode%. In this scenario, the step is the DataRaptor Extract Action named DRReadCase, and the data node to be passed is CaseNumber. Therefore, the merge code %DRReadCase:CaseNumber% correctly retrieves the CaseNumber value from the DRReadCase step's output for use in the subsequent HTTP Action's URL.

1. Salesforce Help

OmniStudio Documentation: "Access Data in an Integration Procedure". This official documentation specifies the use of merge fields. It states

"To access a node in the output of a step

use the syntax %StepName:NodeName%." This directly validates the structure of the correct answer.

2. Salesforce Trailhead

OmniStudio Integration Procedures Module: "Use DataRaptors and Integration Procedures Together". This module provides examples showing that data from a previous step (e.g.

DRGetAccountDetails) is referenced in a subsequent step using the %DRGetAccountDetails:AccountName% syntax. This confirms the pattern of %StepName:Node%.

Cloning an Integration Procedure creates a new, distinct procedure that is completely independent of the original. This is the appropriate action when the new procedure is intended for a separate business process or requires a different lifecycle management path (e.g., a different Type and SubType). Versioning, by contrast, is used for iterative development on the same procedure. A new version maintains the same Type and SubType and is intended to eventually replace the previous active version for all callers of that specific procedure. Therefore, if the new procedure must be used independently, it must be a clone.

1. Salesforce Help

OmniStudio Documentation

"Integration Procedure Versions and Clones": This official documentation explicitly differentiates the two actions. It states

"Create a version when you want to modify an Integration Procedure and eventually replace the older version." For cloning

it implies creating a new

separate procedure

often to be used as a template for a different purpose. The core concept is that a clone becomes an independent asset.

2. Salesforce Help

OmniStudio Documentation

"Create a Version of an Integration Procedure": This guide details the process of versioning for making changes to an existing procedure that will be part of the same lineage. It notes that the Type and SubType are carried over

reinforcing that it's the same logical procedure.

3. Salesforce Help

OmniStudio Documentation

"Clone an Integration Procedure": This document describes cloning as the method to "create an Integration Procedure based on an existing one." This is done to create a new

independent starting point

which directly supports the rationale for using it independently.

To pass all records from a parent FlexCard to a child FlexCard, the developer must reference the entire data node from the parent's data source. By default, or by convention, the array of records returned from a data source (like a DataRaptor) is stored in a node named Records. The syntax {Records} is the correct Merge Field notation to pass this entire array to the child FlexCard, which can then use it to populate its Datatable. This ensures the child has access to the complete dataset from its parent as required.

1. Salesforce Help

OmniStudio Documentation

"Pass Data Between a Parent and Child FlexCard": This official guide explicitly states

"To pass all the data from the parent FlexCard's data source to the child FlexCard

enter the name of the parent's data source JSON node in the Node field. For example

if the parent's data source is a DataRaptor that returns a node called 'Accounts

' enter {Accounts}." This directly validates the use of {Records} when the node is named Records.

2. Salesforce Help

OmniStudio Documentation

"FlexCards Data JSON": This document illustrates the structure of data within a FlexCard. It shows that a data source action populates a top-level node (e.g.

Records

Contacts) which contains an array of objects. To access the entire array

one must reference this top-level node.

3. Salesforce Trailhead

"FlexCard Basics" Module

"Display Data on a FlexCard" Unit: The training materials demonstrate that to iterate over a list of records or pass it to another element

you reference the array node directly

such as {records}. This reinforces the principle of using the node name in curly braces to access the entire dataset.

The Type Ahead element in OmniScript functions as a container block. For the data retrieved by the Type Ahead's DataRaptor to populate other input fields (like Text for FirstName and LastName, or Date for BirthDate), those fields must be nested as child elements inside the Type Ahead Block. When a user makes a selection, the data for the selected record is scoped to the block, allowing it to automatically fill the nested child elements. If the fields are placed outside the block, they are outside its data scope and will not be populated upon selection.

1. Salesforce Help

OmniStudio Documentation

"OmniScript Type Ahead Element": "To populate other elements with the data from the Type Ahead

place the elements inside the Type Ahead Block. For example

to populate the Account Name and Website of an Account

place Text elements for the Account Name and Website inside the Type Ahead block." This directly confirms that target elements must be nested inside the block.

2. Salesforce Trailhead

OmniStudio OmniScripts

"OmniScript Elements" Module: In the unit covering the Type Ahead element

the examples and hands-on challenges demonstrate the required structure of placing input elements that need to be populated (e.g.

Text

Email) directly inside the Type Ahead Block for the data binding to function correctly. This reinforces the container-child relationship.

The primary reason to version a FlexCard is to update it in place. When a new version of a FlexCard is created, modified, and then activated, it automatically replaces the previously active version across all Lightning pages, Experience Cloud sites, and other locations where it is embedded. This ensures that all instances of the component are updated consistently and simultaneously with the new changes, such as modified field labels. Cloning, in contrast, creates an entirely new and separate component that would need to be manually deployed to replace the old one in each location.

1. Salesforce Help

OmniStudio Documentation

"FlexCard Versioning and Cloning": "When you create a new version of a FlexCard and activate it

the new version becomes the active version everywhere the FlexCard is used. For example

if you have a FlexCard on a home page

and you create and activate a new version

the home page is updated with the new version." This directly supports option D.

2. Salesforce Help

OmniStudio Documentation

"When to Clone a FlexCard": "Clone a FlexCard to create a copy of the FlexCard that you can edit and use in a different context. For example

you have a FlexCard on an account record page

but you want a slightly different version on a contact record page." This confirms that the scenario in option A is suited for cloning.

3. Trailhead

Salesforce

"FlexCard Basics" module

"Manage FlexCards" unit: This unit explains the lifecycle of a FlexCard

noting that activating a new version makes it the current

live version

effectively replacing the old one. This reinforces the concept that versioning is for updating an existing

deployed component.

The Text Block element is the most appropriate choice. It is specifically designed as a display element to show read-only information within an OmniScript. It fully supports HTML, which is necessary for creating the required table structure. Furthermore, it can dynamically render data from the OmniScript's data JSON using merge codes (e.g., %FirstName%). This combination of being read-only, supporting HTML formatting, and using merge codes directly addresses all aspects of the developer's requirement.

1. Salesforce Help

OmniStudio Documentation

"OmniScript Display Elements": The Text Block element is described as a tool to "Display read-only text and merge data from the OmniScript's data JSON into the text." It explicitly states that the element supports HTML.

2. Salesforce Help

OmniStudio Documentation

"OmniScript Input Elements": This document categorizes Text Area and Rich Text Area as input elements. The Text Area is for "multiple lines of text

" and the Rich Text Area is for "multiple lines of text with formatting

" confirming their purpose is data capture

not display.

3. Salesforce Help

OmniStudio Documentation

"OmniScript Edit Block Element": This source details the Edit Block's function: "enable users to edit specific fields of an array inline." This clearly defines it as an editing tool

making it unsuitable for a read-only scenario.

DataRaptor Turbo Extracts are optimized for high-performance data retrieval from a single Salesforce object. Their primary advantages are speed and simplicity. They are easier to configure because they do not support complex mappings, formulas, or relationships to other objects, which are features of standard DataRaptor Extracts. This streamlined, single-object focus allows them to execute significantly faster at runtime, making them ideal for populating user interfaces or other processes where response time is critical.

1. Salesforce Help Documentation

"DataRaptor Turbo Extract": "DataRaptor Turbo Extract is optimized for performance. It retrieves data from a single Salesforce object type... DataRaptor Turbo Extract has a simpler configuration than a standard DataRaptor Extract and is limited to retrieving data from a single object."

2. Salesforce Help Documentation

"DataRaptors": This document contrasts the different DataRaptor types

highlighting that standard Extracts are for "complex data structures" and can "access data from multiple objects

" while Turbo Extracts are for "retrieving data from a single object" to improve performance.

The system selects the calculation procedure version that is active at the specified execution time. The execution time is 2/15/2020 at 12:00 PM. By evaluating the effective date ranges for each version, only Version 2 is active during this period. Its start time is 2/1/2020 at 12:00 AM, and its end time is 3/1/2020 at 12:00 AM. The target execution time falls directly within this window, making Version 2 the one that would be executed.

1. Salesforce Help & Training, OmniStudio Documentation, "Calculation Procedure Versions": This documentation specifies that a calculation procedure can have multiple versions, but only one can be active at any given time. The system determines the active version by checking if the current date and time fall between the version's specified Start Date/Time and End Date/Time.

2. Salesforce OmniStudio Developer Guide, "Versioning OmniStudio Components": This guide outlines the versioning model for OmniStudio components, including Calculation Procedures. It confirms that version selection is based on effective dating, ensuring that the correct version is invoked based on the context date, such as an order date or the current system date.

3. Snodgrass, R. T. (1999). Developing Time-Oriented Database Applications in SQL. Morgan Kaufmann. Section 1.2, "Valid Time and Transaction Time": This academic text explains the concept of "valid time," which represents the time period during which a fact is true in the real world. The Start/End dates in the calculation procedure are an implementation of the valid time concept, defining the period of the version's applicability.

The most direct and appropriate method to meet the requirement is to place the contact information inside a Block element and enable its "Collapsible" property. The Block element acts as a container for other elements on the FlexCard. By setting its Collapsible property to true, the platform automatically adds a control (e.g., a chevron icon and label) that allows the end-user to expand and collapse the block's content on demand. This precisely fulfills the requirement for the contact information to be visible only as needed by the user, while the account information remains static.

1. Salesforce OmniStudio Documentation

FlexCard Designer: The official documentation details the properties of FlexCard elements. The "Block" element is described as a container that has a "Collapsible" checkbox property. When selected

the block can be collapsed and expanded by the user. This is the standard

built-in feature for this use case. (Reference: OmniStudio Developer Guide

Section: "FlexCard Element Reference"

Subsection: "Block Element Properties").

2. Salesforce Trailhead

OmniStudio FlexCards: The "Build a FlexCard" module demonstrates the use of various elements. It shows that to group elements and make them collapsible

you should use a Block element and check the "Collapsible" property in the properties pane. (Reference: Trailhead

Module: "OmniStudio FlexCards"

Unit: "Add and Configure Elements on a FlexCard").

The Set Values element with a hardcoded ContextId is a standard practice for testing an OmniScript in isolation, simulating its launch from a specific record page. However, when moved to production, the OmniScript is expected to receive the ContextId dynamically from the record page it is launched from. Leaving the testing-specific Set Values element active would override the dynamic ContextId, forcing the OmniScript to always run against the hardcoded test record's ID. Therefore, the developer must either delete this element or deactivate it to ensure the OmniScript functions correctly in the production environment.

1. Salesforce Industries OmniScript Developer Guide: The guide emphasizes that for an OmniScript to be context-aware (e.g.

when placed on a Lightning Record Page)

it relies on the ContextId being passed in the URL. A Set Values element that defines ContextId will override this dynamic value. The guide's best practices for deployment state that test-specific configurations must be removed. (Refer to sections on "Passing Data to an OmniScript" and "Preparing OmniScripts for Deployment").

2. Salesforce Help & Training - Pass the ContextId to an OmniScript: "To pass a Salesforce object's record Id to an OmniScript

the ContextId is passed as a URL parameter... When you hard-code a ContextId in a Set Values element for testing

you must remove it before you deploy the OmniScript to production." (This concept is detailed in the "Test an OmniScript" section of the documentation).

3. Salesforce Help & Training - OmniScript Set Values Element: This documentation describes the function of the Set Values element for setting static or dynamic values. It implicitly supports the understanding that a static

hardcoded value used for testing is not suitable for a dynamic production environment where the context changes.

The Formula element is the most appropriate choice because it is specifically designed to perform real-time, client-side calculations within an OmniScript step. It can use functions like CONTIF to process data from other input elements in the same step and display the result immediately without requiring a server call. This directly fulfills the requirement for the output to be displayed to the user instantly as they enter data. Using a Formula element is the best practice for this type of immediate UI reactivity.

1. Salesforce OmniStudio Documentation

"OmniScript Formula Element": "Formulas perform calculations in real time on the client side. The result of a formula's expression displays in a read-only field. For example

a formula can calculate the sum of two Number elements and update the sum as the user changes the value of either Number element." This directly supports the use of a Formula element for immediate

real-time display.

2. Salesforce OmniStudio Documentation

"OmniScript Functions": The documentation lists CONTIF as a conditional function available for use within OmniScript elements

including the Formula element

confirming its applicability.

3. Salesforce OmniStudio Documentation

"OmniScript Calculation Action": "A Calculation Action element calls a Calculation Procedure or Calculation Matrix to run complex calculations on the server." This highlights its server-side nature

making it incorrect for the client-side requirement.

An Integration Procedure Action is the most appropriate element as it is designed to execute multiple server-side operations in a single transaction from an OmniScript. The developer can configure the Integration Procedure to first use a DataRaptor Post Action to save data to Salesforce and then use an HTTP Action to send data to the external AWS Order Management system. This allows the OmniScript to trigger both distinct data-saving operations through a single, efficient, server-side call, which is ideal for complex transactions involving multiple systems.

1. Salesforce Help

OmniStudio Integration Procedures: "Integration Procedures can read data from and write data to Salesforce and external systems... For example

an Integration Procedure can get data from an external system using an HTTP action

transform it using a DataRaptor Transform action

and save it to Salesforce using a DataRaptor Load action." This demonstrates the capability of an IP to orchestrate actions involving both Salesforce (via DataRaptors) and external systems (via HTTP Actions).

2. Salesforce Help

OmniScript Actions: "Integration Procedure Action: Runs a server-side Integration Procedure without navigating from the current OmniScript step." This confirms it is the OmniScript element used to invoke the multi-step server process.

3. Salesforce Help

DataRaptor Post Action: "A DataRaptor Post Action saves data that the user enters in an OmniScript to Salesforce." This source explicitly limits its function to saving data to Salesforce.