The type of state that the consultant should recommend to allow users to create a new case from the canvas is New Card State. A New Card State is a state that allows creating new records in a FlexCard using an OmniScript or an Integration Procedure. The consultant can use a New Card State to enable users to create a new case from the canvas, by invoking an OmniScript or an Integration Procedure that writes data to the Case object in Salesforce.

The two pieces of data that the consultant should recommend displaying using FlexCards are: Policies including type, issue date, amount and Customer name, title, phone, email. A FlexCard is a tool that can display data and actions in a card format. The consultant can use FlexCards to show important and summary information about the customer and their policies, such as name, title, phone, email, type, issue date, and amount. These pieces of data are suitable for FlexCards because they are concise and relevant for the agents

The OmniStudio tool that can be used to invoke scheduled jobs is Integration Procedure. An Integration Procedure is a tool that can execute multiple DataRaptor actions, such as Extract, Transform, and Load, and also invoke REST or SOAP services. An Integration Procedure can also be scheduled to run at a specific time or frequency using Apex Scheduler or Process Builder

The FlexCard feature that the consultant should recommend to address this issue is Flyouts. A Flyout is a pop-up window that can display additional information or actions for a FlexCard. The consultant can use Flyouts to show some of the data elements and actions that are not essential for the main view of the product information, such as product details, specifications, reviews, etc. This way, the consultant can reduce the clutter on the main FlexCard and improve the user experience

The most efficient way to meet the requirements is to create a FlexCard with two card states. A card state defines how a FlexCard displays data and actions based on certain conditions. The consultant can use conditions on the state to filter for priority, and then customize the fields and actions for each state. This way, the FlexCard can display different information and options for low/medium and high priority cases

The most efficient approach that the consultant can recommend to the business to meet this requirement is to add a new Step element with Input elements. A Step element can group related fields and elements in an OmniScript, and display them in a page or a section. An Input element can display a field for the user to enter data, such as text, number, date, etc. The consultant can use a Step element to add a new page or section to the OmniScript, and then use Input elements to collect the additional customer information

The task involves migrating legacy Calculation Matrices to Decision Matrices and Calculation Procedures to Expression Sets in OmniStudio. A key consideration arises from the differences in functionality between these tools, particularly with looping logic, making D the correct answer.

Here’s why D. Looping procedures cannot be migrated as Expression Sets is the correct answer:

Migration Context:

Calculation Matrices → Decision Matrices: Calculation Matrices (from older Vlocity tools) are lookup tables that map inputs to outputs. They migrate to Decision Matrices in OmniStudio, which serve the same purpose (e.g., returning a discount based on inputs) and are generally straightforward to convert, as both are data-driven tables stored as Salesforce metadata.

Calculation Procedures → Expression Sets: Calculation Procedures are sequential, logic-driven processes that can include formulas, conditions, and loops. They migrate to Expression Sets in OmniStudio, which are collections of reusable expressions (formulas or conditions) executed in a specific order.

Key Consideration – Looping:

Calculation Procedures: These legacy procedures support looping logic, such as iterating over a list of items (e.g., processing multiple line items in a quote to calculate totals).

Expression Sets: Expression Sets in OmniStudio are designed for linear, non-iterative calculations. They execute a series of expressions (e.g., Total = Price * Quantity) but do not natively support looping constructs like “for each” or “while” loops. Looping requires an Integration Procedure or custom Apex in OmniStudio, not Expression Sets.

Impact: If a Calculation Procedure includes looping (e.g., summing values across a JSON array), it cannot be directly migrated to an Expression Set without rearchitecting the logic. The consultant must consider alternative tools (e.g., an Integration Procedure with a Loop Block) to handle such cases.

Why It’s Key: Failing to account for looping can break the migrated process, as Expression Sets lack this capability. Identifying and addressing looping logic upfront is critical to ensure functional equivalence post-migration.

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

A. Procedures can be migrated without considerations: This is false. Calculation Procedures often include complex logic (e.g., loops, branching), and Expression Sets have limitations (e.g., no looping), requiring careful analysis and potential redesign during migration.

B. Matrices can be migrated with minimal considerations: While migrating Calculation Matrices to Decision Matrices is relatively straightforward (both are lookup tables), “minimal considerations” understates potential issues like data mapping or deprecated features, though looping isn’t a factor here. This isn’t the key consideration compared to D.

C. Matrices can be migrated without considerations: This is incorrect. Even for matrices, considerations like field mappings, data type compatibility, or version differences exist, though they’re less complex than procedure migrations.

Data Mapper Extract is the tool primarily designed to read Salesforce object data and map that data into JSON output for use by OmniStudio components. It is appropriate when the requirement is to retrieve Salesforce records and provide a shaped response to an OmniScript, FlexCard, or Integration Procedure. An Integration Procedure can orchestrate multiple actions and call Data Mappers, but it is not itself the specific extraction-mapping tool. A FlexCard is a UI component that displays contextual data and actions. An OmniScript is a guided interaction layer. The extraction and JSON mapping function belongs to Data Mapper Extract, which reads Salesforce data and outputs it in the required structure.

================

 The three OmniScript elements that should be used to meet these requirements are: Select, DataRaptor Extract Action, and DataRaptor Post Action. A Select element can display a dropdown list of options for the user to choose from, such as payment type. A DataRaptor Extract Action can retrieve data from a Salesforce object, such as saved payment information, and store it in an Interface object or a JSON object. A DataRaptor Post Action can write data to a Salesforce object, such as new payment information, and perform insert or update operations

The requirement is to create " guided interactions " that utilize data from both a Salesforce org and external sources. In Salesforce OmniStudio, OmniScripts is the tool specifically designed for building interactive, guided processes that lead users through a series of steps, integrating and displaying data from multiple sources, including Salesforce and external systems.

Here’s why C. OmniScripts is the correct answer:

Purpose of OmniScripts: OmniScripts are a core OmniStudio component used to create structured, step-by-step user experiences (guided interactions) that can incorporate data from Salesforce objects and external systems. They enable consultants to design dynamic, interactive interfaces with elements like text inputs, picklists, and buttons, guiding users through processes such as filling out forms, updating records, or completing workflows. OmniScripts support integration with other OmniStudio tools (e.g., DataRaptors and Integration Procedures) to fetch and manipulate data, making them ideal for this scenario.

Handling Data from Multiple Sources:

Salesforce Data: OmniScripts can use DataRaptors to extract or update data from Salesforce objects (e.g., retrieving Account details or updating a Case).

External Sources: OmniScripts can leverage Integration Procedures to call external APIs or systems (e.g., pulling customer data from an ERP system) and then display or process that data within the script.For example, an OmniScript could guide a user to input customer information, fetch related Salesforce records using a DataRaptor Extract, and retrieve payment history from an external API via an Integration Procedure—all within a single, cohesive interaction.

Guided Interaction Features: OmniScripts offer a drag-and-drop designer with elements like Steps, Inputs, and Actions, allowing consultants to craft a logical flow. Features like conditional visibility, validation rules, and navigation controls ensure the interaction is guided and user-friendly, meeting the client’s need for a structured experience.

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

A. FlexCards: FlexCards are designed to display data in a concise, card-based format (e.g., a summary of customer details or case status). While they can pull data from Salesforce and external sources (via DataRaptors or Integration Procedures), they are primarily read-only or lightly interactive displays, not tools for creating multi-step guided interactions. FlexCards are better suited for dashboards or quick views, not for guiding users through a process like data entry or decision-making.

B. Integration Procedures: Integration Procedures are powerful tools in OmniStudio for orchestrating complex data operations, such as calling external REST APIs, transforming data, or chaining multiple actions. However, they are backend processes, not user-facing tools. They don’t provide a UI or guided interaction framework—they support OmniScripts or FlexCards by supplying the data or logic needed. Thus, they’re a component of the solution, not the primary tool for guided interactions.

D. Data Mappers: Data Mappers (likely a typo for " DataRaptors " in OmniStudio context) are used to extract, transform, load, or post data between Salesforce and OmniStudio components. For example, a DataRaptor Extract pulls Salesforce data, while a DataRaptor Turbo Extract maps it to JSON. However, DataRaptors are data-handling tools, not UI components. They can’t create guided interactions on their own—they provide the data that OmniScripts or FlexCards use.

Why OmniScripts Stand Out:

OmniScripts are uniquely suited for this requirement because they combine a user interface with data integration capabilities. For instance, a consultant could design an OmniScript to:

Display a welcome step with customer data fetched from Salesforce (via DataRaptor).

Prompt the user to enter additional details, validated in real-time.

Integrate external data (e.g., order status from a third-party system) using an Integration Procedure.

Save all data back to Salesforce or the external system upon completion.This aligns perfectly with the need for " guided interactions " using data from multiple sources.