✅ Explanation:

In a DataRaptor Load, the Default Value column in the Mapping tab is specifically designed to provide a fallback value when the source input is null or missing. By setting the Default Value to "Web" for the LeadSource field mapping, the DataRaptor will automatically apply that value during the load operation if no input value is provided. This is the declarative, built-in way to handle default values within the DataRaptor itself, keeping the logic self-contained and maintainable.

Why other options are incorrect:

A. Set the default value using a required validation rule in the Data Mapper:
Required validation rules are used to enforce that a value must be present—they do not supply a default value. Marking a field as required would cause the DataRaptor to fail if no value is provided, which is the opposite of the requirement.

B. Configure the field-level default value within Salesforce Object Manager:
While this would work for new records created outside of DataRaptors, it does not address the requirement within the DataRaptor itself. The DataRaptor's mapping takes precedence over object-level defaults, and this approach would not be visible or maintainable within the OmniStudio tooling.

C. Enable the fallback value property in the Data Mapper Options tab:
There is no "fallback value property" in the Options tab for DataRaptors. Default values are configured per-field in the Mapping tab, not globally.

🔗 References:

Salesforce OmniStudio Developer Guide → "Use the Default Value column in the DataRaptor Load Mapping tab to set a fallback value when the source field is null or missing."

Trailhead: Load Data with DataRaptors → "Default values ensure data integrity by providing a specified value when input is unavailable."

✅ Explanation:

The root cause of the slow loading is that the Integration Procedure is fetching 50 fields but only five are displayed on the UI. This creates unnecessary overhead in multiple areas:

Larger SOQL query → increases query time and consumes more rows toward governor limits.
Larger JSON payload → increases network transfer time and browser memory consumption.
Slower parsing→ the FlexCard must parse and process unnecessary data.

The recommended optimization is to modify the Integration Procedure (or the DataRaptor it calls) to return only the five fields actually displayed. This reduces query complexity, shrinks the payload, and speeds up rendering without any functional loss. This aligns with the best practice of "fetch only what you need."

Why other options are incorrect:

A. Enable client-side processing on the FlexCard:
Client-side processing moves some logic to the browser, but it does not reduce the amount of data fetched. The 50 fields are still being transmitted and parsed—client-side processing would not solve the payload size issue.

B. Replace the Integration Procedure with a SOQL data source:
This is not recommended in OmniStudio. While SOQL is fast, Integration Procedures provide orchestration, error handling, and reusability that a raw SOQL data source cannot. The correct fix is to optimize the existing IP, not replace it entirely.

C. Increase the FlexCard timeout setting:
This addresses a symptom (timeout error) but not the root cause (slow data retrieval). Increasing the timeout would make the user wait even longer, worsening the user experience. The solution is to reduce the data being fetched, not increase the wait time.

🔗 References

Salesforce OmniStudio Developer Guide → "Optimize DataRaptors and Integration Procedures to return only fields needed by the consuming component."

Trailhead: Optimize FlexCard Performance → "Reduce the number of fields and records fetched to improve load times."

✅ Explanation:

The requirement is to display a list of recent transactions with branded styling and allow agents to dispute a transaction directly from the list via an action button. This is the primary use case for FlexCards—they are interactive, data-driven UI components designed to:

Display data in visually branded layouts (matching the bank's website).
Include interactive actions (e.g., a button to dispute a transaction).
Be embedded on a customer profile page alongside other components.

FlexCards are purpose-built for this scenario because they present information in a card-based format that supports branding, actions, and real-time data binding—all without requiring custom code.

Why other options are incorrect:

B. Present guided steps using OmniScript:
OmniScripts are for step-by-step wizards (e.g., dispute a transaction across multiple screens). However, the requirement here is primarily about displaying a list and offering a single action—not a guided process. While OmniScript could be launched from the FlexCard for the dispute, the primary display role belongs to FlexCards.

C. Visualize data using Tableau:
Tableau is for advanced analytics and visualizations (charts, graphs, dashboards). The requirement is a simple list of transactions with an action button, not complex data visualization.

D. Query data using Apex:
Apex is used for backend logic and data queries. While it may be used behind the scenes, it is not a UI component. The role of OmniStudio in this scenario is to provide the interactive display layer, not the data layer.

🔗 References

Salesforce OmniStudio Developer Guide → "FlexCards present interactive, data-driven information in a card-based UI with branding and actions."

Explanation:

A record locking error during DataRaptor Load execution occurs when two or more concurrent transactions attempt to update the same Salesforce record simultaneously. Salesforce uses record-level locking to maintain data integrity—when one transaction holds a lock on a record (typically during an update operation), other transactions must wait until the lock is released. If the wait exceeds the configured timeout, Salesforce throws a lock error.

This situation commonly arises in high-volume integration scenarios where:
Multiple Integration Procedures or OmniScripts are executing concurrently and updating the same customer, case, or order records.
A batch job and a real-time process overlap on the same record set.
The same DataRaptor Load is called multiple times within a short window (e.g., from a triggered OmniScript and an automated flow).

Best practices to resolve this include:
Implementing retry logic with exponential backoff.
Redesigning the data flow to avoid concurrent updates to the same records.
Using SELECT ... FOR UPDATE cautiously in Apex to explicitly lock records in sequence.
Reducing transaction duration by minimizing the number of DML operations per DataRaptor Load.

Why other options are incorrect:

A. Lack of field-level permissions:
Missing field permissions cause FIELD_PERMISSION or INSUFFICIENT_ACCESS errors, not record locking errors. The error message would explicitly indicate access denial rather than lock contention.

B. Record being archived by a system job:
Salesforce archiving does not produce record locking errors. Archiving typically moves data to an external system or prevents updates to archived records, throwing a different error (e.g., "Archived record cannot be updated"). This is unrelated to concurrent update conflicts.

C. Exceeds the maximum batch size:
Exceeding batch size limits results in BATCH_SIZE_EXCEEDED errors during bulk operations. This error relates to chunking or bulkification, not individual record locking. DataRaptor Loads process records one by one unless explicitly configured for bulk mode.

References:

Salesforce Developer Guide → "Record locking occurs when a transaction holds a lock on a record and another transaction attempts to update it."

Explanation

Calculation Matrices are specifically designed in OmniStudio to handle complex, rule-based pricing, discounting, and eligibility logic that relies on multiple input variables.

In the scenario described:

Inputs are the "number of lines" and "internet coverage" on the current plan.

The Output is the "discounted rate."

A Calculation Matrix allows you to define a lookup table where different combinations of the input variables (e.g., 4 lines and Fiber coverage) map directly to a specific output value (e.g., a 15% discount). This makes the complex business logic transparent, declarative (no code required), and easy to manage, update, and version.

Why the other options are not the best choice:

A. DataRaptor Turbo and D. DataRaptor Transform are used primarily for retrieving, transforming, and loading data, not for complex, conditional lookup calculations like pricing and discounting. While a standard DataRaptor Extract can use formulas, the structure of pricing rules is better handled by a dedicated matrix tool.

B. OmniStudio Action (specifically a Calculation Action) is for performing simple calculations and logic within an OmniScript, but it's not the correct tool for defining and managing the tiered, matrix-based business rules described. A Calculation Procedure (which uses a Calculation Matrix) would be called by an OmniScript action to get the rate.