When multiple components on a single page all fail simultaneously (for example, due to a shared service failure), individual toast messages stack up, creating a poor user experience. To resolve this, developers should shift away from "ephemeral" notifications like toasts toward more structured error handling.
Option A involves creating a dedicated error-handling component. This component can act as a listener or a central repository for errors across the page. Instead of each component firing its own toast, they can communicate their error state to this central component, which aggregates the messages into a single, clean display. This reduces visual clutter and allows the user to read all errors in one place.
Option C refers to "in-place" error handling. Using conditional rendering (the lwc:if or template if:true directives), a component can hide its normal UI and display an error message exactly where the component would have been. This provides immediate context to the user about which specific part of the page failed without interrupting the overall flow with pop-ups.
Option B (window.alert) is considered a legacy practice that blocks the browser thread and is generally avoided in modern web development. Option D (public properties) is a mechanism for component communication but doesn't solve the display problem itself. Combining A and C provides a modern, professional, and less intrusive error-handling strategy.

In Salesforce, a callout cannot be made directly from an Apex trigger (Option C). This is a fundamental architectural restriction of the platform. Triggers execute as part of a database transaction. If a trigger were allowed to make a synchronous callout, the database transaction-along with all its associated row locks- would remain open while waiting for a response from the external system. This could lead to severe performance bottlenecks and transaction timeouts.
To perform a callout based on a trigger event, the developer must move the callout logic into an asynchronous context, such as a @future(callout=true) method, a Queueable class, or by publishing a Platform Event.
Option A is incorrect because while asynchronous methods allow for higher CPU time, they do not extend the maximum individual callout timeout (120 seconds). Option B is incorrect because REST is simply a protocol and does not dictate synchronicity. Option D is incorrect because the limit for callouts in a single transaction is 100, so 10 callouts would still be permissible in a synchronous context (assuming they aren't in a trigger).
Consequently, the presence of a trigger is the only factor listed that programmatically mandates an asynchronous approach.

Testing asynchronous Apex, such as the Queueable interface, requires specific handling to ensure the job actually executes during the test run and adheres to platform limits.
First, Salesforce enforces a strict limit on chaining Queueable jobs during unit tests. Specifically, you cannot chain jobs (enqueue a job from another job) within a test. Since the OrderQueueableJob attempts to enqueue FollowUpJob, the test will throw an error. To resolve this, the developer should use Test.isRunningTest() (Option B) within the execute method to conditionally bypass the System.enqueueJob call during test runs.
Second, asynchronous jobs are queued by the system and do not run immediately. To force the execution of a Queueable job so that results can be asserted, the System.enqueueJob call must be wrapped within Test.
startTest() and Test.stopTest() (Option D). When Test.stopTest() is called, the execution pauses until all queued asynchronous jobs in that block finish running.
Option A is incorrect because seeAllData does not affect asynchronous processing modes. Option C is incorrect because the class is defined as without sharing, meaning it bypasses sharing rules regardless of the running user's permissions. By combining recursion/chaining guards and the startTest/stopTest block, the developer can reliably test the logic within the execute method.

To adhere to the DRY (Don't Repeat Yourself) principle and ensure maintainability, business logic should be decoupled from specific execution contexts like triggers.
Option C is a best practice. By moving the logic into a Service or Helper class, the code becomes reusable.
The trigger can call this class during DML operations to flag records, and an Apex controller (invoked by the Lightning Web Component) can call the same class to retrieve the high-value records for display. This ensures that if the criteria for "high-value" changes, the developer only needs to update the code in one location.
Option D complements this by externalizing the "High Value Amount" threshold. Instead of hardcoding a value (e.g., $100,000) within the Apex code, storing it in Custom Metadata allows administrators to adjust the threshold without requiring a code deployment. The helper class can dynamically query this metadata.
Option A is technically impossible; triggers are fired by the database system in response to DML, not called directly by UI components. Option B leads to "Trigger Bloat" and prevents the LWC from accessing the logic, forcing duplication. Together, C and D provide a scalable, configurable, and reusable architecture.

In the Aura Component framework, "Quick Actions" are used to extend the functionality of the Salesforce UI, allowing developers to surface custom components in modal pop-ups from the "Buttons, Links, and Actions" section of an object.
To make an Aura component available as a Quick Action, it must implement the force:
lightningQuickAction (Option D) interface.2 When this interface is added to the <aura:component> tag, the component becomes selectable when creating a new "Action" for an object. When a user clicks the corresponding button on the record page, Salesforce automatically wraps the component in a standard modal dialog box.
If the requirement specifically calls for the modal to occupy more screen real estate, the developer can also use force:lightningQuickActionWithoutHeader, which removes the standard "Save" and "Cancel" buttons and the header, providing a blank canvas within the modal.3 Option B is incorrect as the prefix must be force:, which refers to the library of interfaces provided by the Lightning Experience container. Option A and C are not standard interfaces for this purpose. Implementing force:lightningQuickAction is the standard way to bridge custom Aura logic with the native Salesforce record page button functionality.