Salesforce Certified OmniStudio Developer Exam Dumps & Practice Test Questions

Question 1:

A developer is creating an OmniScript that sets up trial Salesforce orgs for new customers. There's a text block included that should display the trial org ID using a merge code. The current text reads:Despite having the correct data in the JSON structure, the ID does not appear when the script is executed.

What is the correct modification the developer should apply to the merge code to ensure the ID is displayed?

A. %Details:Customer|n:ID%
B. $Details:Customer|0:ID$
C. %Details:Customer|1:ID%
D. %%Details:Customer|0:ID%%

Correct Answer: D

Explanation:

In OmniStudio's OmniScript, developers often use merge codes to dynamically display data within UI elements such as text blocks. These merge codes extract specific values from the JSON data structure and insert them into the script interface. For merge codes to function properly, they must follow a specific syntax recognized by the OmniScript engine.

In this case, the developer uses a merge code to display the ID from the first customer object in the Details JSON structure. The syntax they used was:
%Details:Customer|0:ID%

While the logic for accessing the customer’s ID at index 0 is correct, the merge code is improperly formatted. OmniScript requires that merge codes be enclosed using double percent signs — not a single pair — to evaluate and render the value properly. The correct format should be:
%%Details:Customer|0:ID%%

Without the double percent signs, the system treats the content as plain text rather than as a dynamic expression to evaluate. That is why the ID is not appearing during runtime, even though the data exists in the underlying JSON.

Let’s examine the other options:

• A. %Details:Customer|n:ID%
  This syntax uses an invalid index (n) which is not acceptable in OmniScript merge codes. Indexes must be numeric, like 0, 1, etc.

• B. $Details:Customer|0:ID$
  This uses dollar signs instead of percent signs, which are not valid delimiters in OmniScript. $ symbols are used in different Salesforce contexts, such as formulas or JavaScript expressions, but not in OmniScript merge tags.

• C. %Details:Customer|1:ID%
  While this uses a valid structure, it assumes the data is at index 1, not 0, which contradicts the original reference. If the intended data is at index 0, this will not yield the desired value.

• D. %%Details:Customer|0:ID%%
  This is the accurate and complete merge code syntax for OmniScript. It uses the correct index (0) and is enclosed in double percent signs to ensure the merge code is parsed and rendered correctly at runtime.

To summarize, the merge code was technically close but syntactically incorrect. Wrapping it in double percent signs resolves the issue and correctly displays the ID.

Question 2:

A developer is building an OmniScript that needs to retrieve several fields from a Salesforce record to use within the script’s flow.

Which OmniScript element should the developer use to retrieve this data directly from Salesforce?

A. Lookup
B. HTTP Action
C. Select
D. DataRaptor Extract Action

Correct Answer: D

Explanation:

OmniScript in Salesforce Industries (formerly Vlocity) enables developers to create guided, user-friendly flows that interact with Salesforce data and other systems. A frequent requirement in these scripts is retrieving fields from Salesforce objects like Account, Contact, or Case records. For this type of use case, the best tool available is the DataRaptor Extract Action.

DataRaptor Extracts are specifically designed to fetch data from Salesforce objects. You can configure them to pull multiple fields from a record by specifying the object type, filter criteria (such as record ID), and desired fields. Once the DataRaptor is set up, it returns the data in JSON format, which the OmniScript can then use in UI elements, conditional logic, or downstream integrations.

Let’s evaluate the other options:

• A. Lookup
  The Lookup element is primarily used for referencing static datasets or cross-referencing small value sets (like picklists). It does not interact with Salesforce records or perform data queries against the Salesforce database. Hence, it cannot fetch fields from a record dynamically and is not suitable here.

• B. HTTP Action
  This element is used to make API calls to external systems or services. While you could technically call a Salesforce REST API endpoint using an HTTP Action, this approach is inefficient and unnecessary when working within the Salesforce platform. It introduces additional complexity and performance overhead.

• C. Select
  The Select element is a UI component that provides a dropdown menu to users. While it can display dynamic data (if sourced appropriately), it does not retrieve data by itself. It simply displays values that have already been retrieved through another element, like a DataRaptor.

• D. DataRaptor Extract Action
  This is the ideal and purpose-built solution. By using a configured DataRaptor Extract and adding it to your OmniScript as an Extract Action, you can seamlessly retrieve Salesforce data. The returned data is parsed into the script’s JSON structure and can be mapped to various UI elements or used in conditions and branching logic.

In summary, the DataRaptor Extract Action is the go-to tool within OmniScript when you need to pull multiple fields from a Salesforce record. It is efficient, easy to configure, and tightly integrated into the OmniStudio architecture.

Question 3:

A developer is configuring an OmniScript that includes a Type Ahead Block to enable users to search for and choose a contact. Once the contact is selected, the developer wants to display the contact’s FirstName, LastName, and BirthDate. The DataRaptor used with the Type Ahead Block retrieves the correct information. However, during testing, the text fields for FirstName, LastName, and BirthDate remain empty after a contact is selected. 

What is the most probable reason why the selected contact’s information isn’t being displayed in the text fields?

A. Use Data JSON is not selected in the properties of the Type Ahead Block
B. The Typeahead Key is not in the correct format
C. Lookup Mode is not selected in the properties of the Type Ahead Block
D. FirstName, LastName, and BirthDate are not placed inside the Type Ahead Block

Correct Answer: D

Explanation:

In OmniStudio’s OmniScript framework, a Type Ahead Block is used to fetch a list of options from a data source (like contacts) and allow the user to select one. When the user selects a contact, the goal is often to populate related fields such as FirstName, LastName, and BirthDate based on that selected contact’s data. This functionality depends heavily on how the fields are structured within the OmniScript.

Here, the developer confirms that the DataRaptor correctly retrieves data and that the Type Ahead search and selection function properly. However, after selecting a contact, the additional fields do not populate with data. This behavior indicates a data binding issue, specifically caused by how the fields are positioned in the OmniScript layout.

For OmniScript to automatically bind and populate data from a selected record, the fields intended to display this data must be nested inside the Type Ahead Block. This ensures that the data context aligns with the selected item. If those fields are placed outside the block, they are not correctly bound to the selection’s data path in the Data JSON structure, resulting in them displaying as blank.

Let’s evaluate the incorrect options:

• A. “Use Data JSON” not being selected may prevent data from being mapped correctly in some use cases, but it typically doesn’t stop fields within the Type Ahead Block from being populated—especially if the record selection already works.

• B. An incorrectly formatted Typeahead Key might affect what appears in the dropdown list, but it would not cause the issue of fields failing to populate after selection.

• C. Lookup Mode is more about controlling how the search behaves—it doesn’t affect how fields are bound to the returned data.

Therefore, the root issue is structural—the fields that need to receive data (FirstName, LastName, BirthDate) are not placed within the Type Ahead Block. Once moved inside, they’ll correctly bind to the selected contact and display the expected values.

Question 4:

An OmniScript is designed to retrieve and display data from an external API using an Integration Procedure. However, when testing the script, none of the expected API data is shown. 

What are two possible reasons why the data is missing in the OmniScript output? (Choose two.)

A. The API URL has not been allowlisted in Salesforce
B. The JSON structure sent from the Integration Procedure doesn’t match the defined Original Input
C. There is no active version of the OmniScript
D. The Integration Procedure’s expected input parameters don’t match what the OmniScript is sending

Correct Answers: A, D

Explanation:

When an OmniScript interacts with an external API via an Integration Procedure (IP), multiple layers of configuration must align for the data to be successfully retrieved and displayed. The API call has to go through Salesforce’s security model, and the data exchange between the OmniScript and the Integration Procedure must be properly structured. If either fails, the script may render but show no data.

A. The API URL is not allowlisted — This is a common issue. Salesforce enforces strict security controls to protect data and external integrations. Any outbound call made to an external API must be explicitly allowed in Remote Site Settings or via Named Credentials. If the API is not on this allowlist, the call will be blocked entirely. No data will be returned, and depending on how error handling is configured, the script might not show any indication of failure—just a lack of content.

D. The input parameters from the OmniScript don’t match what the Integration Procedure expects — This mismatch can cause the Integration Procedure to behave incorrectly or return empty data. For instance, if a required input value like a customer ID is missing or formatted incorrectly, none of the steps within the IP will run, or they might produce empty results. Even though the Integration Procedure is triggered, without the right parameters, it cannot process the logic properly. As a result, the OmniScript receives no usable response.

Now let’s examine why the other two options are incorrect:

• B. The “Original Input” in the Integration Procedure designer is a testing artifact, not a runtime requirement. At runtime, Integration Procedures accept whatever JSON structure is sent and act based on internal logic. A mismatch here would not block execution entirely unless the internal logic fails due to missing fields.

• C. An OmniScript without an active version would not load at all. If the user is able to preview or run the script, it means there is indeed an active version deployed.

In conclusion, the most probable causes for missing data are that the external API URL is not properly allowlisted (A) and that the JSON input from the OmniScript does not align with the expected structure in the Integration Procedure (D).

Question 5:

A developer is working on an Integration Procedure that uses an HTTP action to retrieve a JSON response from a REST API. This response needs to be converted into a specific XML structure before it can be sent to a second external system via another HTTP call.

What is the best approach the developer should take to handle this transformation within the Integration Procedure?

A. Use a DataRaptor Transform to convert JSON into XML
B. Use a Remote Action that calls the XMLStreamReader class
C. Use a DataRaptor Extract and enable the XML checkbox for the Output JSON Path
D. Use a Remote Action that calls the XMLStreamWriter class

Correct Answer: D

Explanation:

When using OmniStudio Integration Procedures to handle external API communication, developers frequently need to manage different data formats, such as JSON and XML. REST APIs often return data in JSON, whereas legacy systems and some enterprise applications may require XML-formatted input. This discrepancy demands a reliable method to convert JSON to XML within the Integration Procedure workflow.

In this scenario, a JSON payload is received from an initial HTTP action. The next step is to transform that data into a valid XML structure that conforms to the schema requirements of the destination web service. Let's examine the answer choices:

A. Using a DataRaptor Transform is not suitable for this task. Although DataRaptor Transforms are effective for converting and mapping JSON data, they are specifically designed to work with JSON. They cannot natively output XML. OmniStudio lacks built-in support for converting JSON into XML using DataRaptor tools.

B. The XMLStreamReader class is designed for reading XML, not generating it. It serves the purpose of parsing XML data into usable structures but is irrelevant when the goal is to produce XML from JSON. Using this class would be counterproductive in a scenario that requires XML generation.

C. A DataRaptor Extract is used to pull Salesforce object data and return it in JSON format. There is no setting that allows a developer to toggle an XML output option for the Output JSON Path. Even if such a checkbox existed, DataRaptors do not support native XML output. This makes this option invalid.

D. A Remote Action that uses the XMLStreamWriter class is the correct solution. This approach allows developers to implement custom Apex code that generates XML strings. The XMLStreamWriter class provides methods to write start and end tags, attributes, and data elements, enabling precise control over the structure of the resulting XML. When this logic is invoked through a Remote Action, the Integration Procedure can pass the JSON to the Apex code, generate the required XML structure, and then route it to another HTTP action.

This setup ensures compatibility with systems requiring strict XML formats and provides flexibility to handle any schema complexity that native tools cannot accommodate.

Question 6:

A developer has created a FlexCard that includes five different states. Four of these states use conditional logic to determine whether they should be displayed. During testing, the input data causes two of the conditions to evaluate as true.

How does the FlexCard determine which one of the matching states will be shown?

A. The first state with a true nested condition is displayed, regardless of its position
B. The first state with a true condition that appears closest to the top of the FlexCard canvas is shown
C. The first state with a true AND condition is shown, regardless of sequence
D. The first state in the FlexCard canvas is displayed

Correct Answer: B

Explanation:

FlexCards are an essential part of OmniStudio’s front-end framework, used for building lightweight, responsive user interfaces. Each FlexCard can have multiple states, allowing it to present different layouts or information depending on the data context. A state is essentially a UI configuration that is displayed when specific conditions are met.

In this case, the FlexCard has five states, with four of them dependent on conditions. When two of these conditions evaluate to true at runtime, the system must determine which one to render.

Here’s how the state resolution mechanism works:

FlexCard states are evaluated in order, based on their vertical position on the canvas. The engine checks each state from top to bottom. As soon as it finds a state whose condition evaluates to true, it renders that state and stops evaluating the rest. This design ensures performance optimization and a predictable rendering flow.

Let’s assess each option:

A. The notion that the “first state with a true nested condition” is prioritized is incorrect. Whether the condition is nested or not has no impact on the rendering priority. Only the result of the entire condition matters, and the position in the canvas determines order.

B. This is the correct choice. The FlexCard evaluates states in their defined sequence on the canvas. The first one (from the top down) with a condition that evaluates to true is selected. Even if multiple conditions are true, only the first valid one is rendered. This gives developers control to prioritize states simply by moving them up or down in the layout.

C. The presence of an AND condition has no effect on priority. The evaluation does not give preference to certain logical operators. All conditions, regardless of complexity, are treated equally; what matters is whether the full expression is true.

D. This is partially true but misleading. The first state on the canvas is only selected if its condition is true. If it is false, it is skipped in favor of the next matching state. Thus, sequence alone does not guarantee rendering unless paired with a true condition.

In conclusion, state rendering is sequence-based among those with true conditions, making it essential for developers to strategically order states on the FlexCard canvas.

Question 7:

A developer is working on a DataRaptor Load that will be used inside an Integration Procedure, which in turn is triggered by an OmniScript. 

To avoid mapping errors and ensure that data flows correctly between these components, what is the recommended way to define the Input JSON structure for the DataRaptor Load?

A. Construct the JSON manually, node by node, using a text editor.
B. Use the DataRaptor Designer to manually build the JSON structure.
C. Copy the Input JSON from the {Data} modal of the OmniScript during preview.
D. Extract the Input JSON from the debug output of the DataRaptor Action node.

Correct Answer: C

Explanation:

In OmniStudio development, ensuring the Input JSON structure matches across the OmniScript, Integration Procedure, and DataRaptor is crucial. Any misalignment in keys, nesting, or structure can result in runtime errors or incomplete data loading. When integrating a DataRaptor Load into an Integration Procedure triggered by an OmniScript, the safest and most reliable approach is to use the actual runtime data from the OmniScript.

Let’s explore the options:

Option A suggests building the Input JSON manually using a text editor like Notepad or VS Code. This method is prone to human error such as mislabeling nodes or incorrect nesting. Since it relies solely on guesswork, it does not account for the actual data context of the OmniScript, making it an unreliable method.

Option B recommends constructing the JSON manually using the DataRaptor Designer. While the designer is useful for testing and previews, it doesn’t automatically reflect the structure generated by the OmniScript. You would still need to guess field names and structures, which can easily lead to mismatches.

Option C, the correct answer, involves copying the JSON directly from the OmniScript’s {Data} modal while previewing. This modal shows the live JSON that the OmniScript generates, including all user inputs and values from prior elements. By copying this structure, you ensure that the DataRaptor Load receives exactly what the Integration Procedure will pass along. This eliminates the guesswork and greatly reduces the likelihood of errors in field mapping.

Option D refers to copying JSON from the DataRaptor Action debug output. While this is helpful for troubleshooting after execution, it isn’t ideal for initial setup. It reflects data that was already passed to the DataRaptor and may not fully represent the intended structure.

In summary, pulling the Input JSON directly from the OmniScript’s data modal ensures consistency, aligns with best practices, and provides a reliable source of truth for configuring the DataRaptor Load. This approach improves stability and reduces mapping errors between OmniScript, Integration Procedure, and DataRaptor components.

Question 8:

A developer created a DataRaptor Load to insert Contact records using firstName and lastName as required fields. The DataRaptor works perfectly in preview mode. After integrating it into an Integration Procedure and using a Set Values element to populate the inputs, an error occurs during testing: “Required fields are missing: [Last Name]”.

What is the most likely cause and how can it be resolved?

A. The output node from the Set Values action should be added to the "Additional Input" section of the DataRaptor Post Action.
B. The Set Values action should use the element name of the DataRaptor Post Action as a prefix in its keys.
C. The DataRaptor Post Action should run before the Set Values Action.
D. The missing field should be manually added in the DataRaptor’s Domain Object settings.
Correct Answer: A

Explanation:

When integrating a DataRaptor Load inside an Integration Procedure (IP), passing data correctly between IP elements is critical. The issue described—“Required fields are missing: [Last Name]”—suggests that the Integration Procedure isn’t providing the necessary inputs to the DataRaptor, even though the values are being defined using a Set Values element.

Let’s break down what’s happening:

The Set Values element correctly assigns values like firstName and lastName in a JSON node (e.g., SetValuesContactDetails). However, unless this JSON node is explicitly linked to the DataRaptor Post Action, the DataRaptor won’t know where to get its input. This is where the “Additional Input” configuration becomes important.

Option A is the correct resolution. In the Integration Procedure, you need to navigate to the DataRaptor Post Action element and open its “Additional Input” section. Here, you must provide the path to the node created by the Set Values element (e.g., SetValuesContactDetails). This tells the Integration Procedure to pass that specific data structure into the DataRaptor, ensuring that all required fields like lastName are available when the DataRaptor executes.

Option B is incorrect because Set Values does not need to reference downstream element names like LoadContactDetails:lastName. Element names are not intended to be used in this way, and doing so introduces unnecessary complexity without solving the actual issue.

Option C mistakenly reverses the execution order. Integration Procedures run elements from top to bottom, so the Set Values must logically appear before the DataRaptor Post Action. Running the DataRaptor before values are even set would result in incomplete or missing input.

Option D refers to the Domain Object setting within the DataRaptor, which controls internal field mappings but has no effect on data being passed in from the Integration Procedure. Since the DataRaptor works independently, it confirms that the internal mappings are already correct.

In summary, the Integration Procedure must be configured to properly route the output of the Set Values element to the DataRaptor Post Action using the “Additional Input” section. This ensures all required inputs are available at runtime and resolves the missing lastName field error.

Question 9:

A developer is tasked with creating a FlexCard that shows both account and contact details. The card must always display the account’s name, address, phone number, and website. However, the contact’s first name, last name, phone number, address, and email should only appear if a user chooses to view them. 

What is the most appropriate method for implementing this behavior on the FlexCard?

A. Enable the collapsible property on the block element
B. Display contact information using a Datatable element
C. Utilize a conditional state within the FlexCard
D. Add class="collapsible" to the block element

Correct Answer: A

Explanation:

In Salesforce OmniStudio, FlexCards are a powerful way to present key data in a concise, interactive layout. They are made up of blocks, which can be conditionally displayed or interactively shown/hidden depending on user input or data conditions. In this case, the developer needs to build a card where the account information is always visible, while the contact information is optionally shown based on user interaction.

Let’s review the options:

A. Enable the collapsible property on the block element
This is the correct approach. The collapsible property is a built-in feature in FlexCards that allows developers to hide or reveal blocks based on user interaction. By setting this property on the block that contains contact information, the data is hidden by default but can be expanded when the user clicks on it. This provides a smooth and intuitive user experience without requiring complex conditions or additional configuration. Most importantly, it aligns directly with the use case described—making part of the data (contact info) optionally visible.

B. Display contact information using a Datatable element
This is not suitable. Datatables are typically used to display multiple records (like lists of contacts or transactions) in tabular form. This use case involves displaying data for a single contact in a collapsible manner, not rendering a list. Datatables also do not provide simple expand/collapse functionality.

C. Utilize a conditional state within the FlexCard
While this method could technically achieve the desired effect, it introduces unnecessary complexity. FlexCard states are typically used for entirely different layouts or views based on certain conditions. Using states to toggle the visibility of a small section like contact details would require extra logic and could negatively affect performance and maintainability.

D. Add class="collapsible" to the block element
This option assumes the use of raw CSS classes, which is not recommended in the context of Salesforce’s FlexCard configuration. The collapsible property exists for this exact purpose and should be used instead of relying on unsupported or custom class names that might not function correctly.

In summary, enabling the collapsible property on the contact block offers a clean, native, and easily maintainable solution to control visibility while keeping the account data always available. This solution is built into the platform and requires minimal configuration effort.

Question 10:

In an Integration Procedure, which two fields allow the use of functions like CONCAT or DATEDIFF for manipulating data? (Choose two.)

A. Tracking Custom Data value field in Procedure Configuration
B. Additional Input value field in a Response Action
C. Additional Output value field in a Remote Action
D. Remote Options value field in a Remote Action

Correct Answers: B, C

Explanation:

Salesforce OmniStudio’s Integration Procedures are designed to streamline data interactions and transformations between systems. To support this, Integration Procedures allow developers to use built-in functions such as CONCAT (for string concatenation) and DATEDIFF (for calculating date differences) within specific action fields. These functions are crucial for formatting or transforming data during input/output operations.

Let’s evaluate each option:

A. Tracking Custom Data value field in Procedure Configuration
This is not correct. Tracking Custom Data fields are used for tagging data used during the execution of an Integration Procedure—such as timestamps or metadata—but they are not processing points for data transformation. These fields typically store static or predefined values and don't support function operations like CONCAT or DATEDIFF.

B. Additional Input value field in a Response Action
This is correct. The Additional Input field in a Response Action is used when passing specific values to external systems or components. Within this field, developers can use functions such as CONCAT to format full names (e.g., first + last name) or DATEDIFF to calculate durations. This capability allows developers to dynamically alter the payload sent during integration without hardcoding values.

C. Additional Output value field in a Remote Action
This is also correct. Remote Actions invoke external APIs or Apex classes, and the Additional Output field can be used to format or transform response data before passing it back to the Integration Procedure. By using functions like CONCAT and DATEDIFF here, developers can ensure that the data returned fits the exact formatting or calculation needed for further logic downstream.

D. Remote Options value field in a Remote Action
This is incorrect. Remote Options fields are generally used for configuration purposes, such as specifying the endpoint URL, authentication headers, or timeout settings. These are not intended for data manipulation or transformation, and functions like CONCAT or DATEDIFF are not evaluated in these fields.

In conclusion, functions like CONCAT and DATEDIFF should be used in contexts where actual data values are transformed, particularly in Additional Input and Additional Output fields where data is formatted or calculated for integration. Using these functions properly ensures that data passed to or received from systems is in the correct structure and value.