Free Salesforce PDII Practice Exam with Questions & Answers | Set: 3

For high-volume, automated standard email communications, Email Alerts with Flow Builder (Option B) is the most scalable and maintainable solution. Salesforce imposes strict limits on the number of "Single" emails sent via Apex (typically 5,000 per 24 hours). However, emails 5sent via Workflow Rules, Process Builder, or Flow6 Builder (Email Alerts) have a much higher daily limit (2,000,000 per org).

To meet the requirement of 10,000 emails per day, an Apex-based solution using SingleEmailMessage() (Option D) would likely hit the daily limit and cause transaction failures. MassEmailMessage() (Option C) is generally intended for manual mass mailing to Contacts or Leads and is not optimized for automated, per-record trigger logic. While Batch Apex (Option A) could process many records, the underlying SingleEmailMessage limit would still apply.

By using an Email Alert triggered by a Record-Triggered Flow, the developer leverages the platform's high-volume email engine. This approach is declarative, requires no custom code, is easier for administrators to maintain, and comfortably handles the 10,000 daily email requirement without risking governor limit exceptions. It also ensures the "criteria evaluation" happens within the standard Flow entry conditions.

==========

Compreh17ensive and Detailed 11850 to 250 words of Explanation:

To make an Apex method compatible with a Lightning Web Component's @wire service and ensure it follows security best practices, three specific modifications are required:

@AuraEnabled(Cacheable=true) (Option C): The @wire service in LWC requires the Apex method to be marked as cacheable. This enables client-side caching via the Lightning Data Service, which significantly improves UI performance by reducing redundant server calls. Note that Cacheable=true is mandatory for @wire but optional for imperative calls.

with sharing (Option B): In Apex, classes do not enforce sharing rules by default. To ensure the user only sees Leads they have access to according to the organization-wide defaults and sharing model, the class must explicitly use the with sharing keyword.

WITH SECURITY_ENFORCED (Option A): While with sharing handles record-level access, it does not automatically enforce field-level security (FLS) or object-level security (CRUD). Adding the WITH SECURITY_ENFORCED clause to the SOQL query ensures that if a user does not have permission to view the AnnualRevenue field, the query will throw an exception rather than exposing protected data.

Options D and E are incorrect because without sharing bypasses security, and a simple @AuraEnabled without cacheable=true is insufficient for the LWC @wire service.

This scenario presents two distinct requirements: processing a large volume of data (50,000 records) and running the process at a specific time (once a day after business hours).

Database.Batchable (Option B): Processing 50,000 records in a single synchronous transaction will exceed Apex Governor Limits (specifically the CPU time limit or the heap size limit). Batch Apex allows the system to process these records in smaller chunks (batches), ensuring that the calculation completes without hitting limits.

Schedulable (Option C): To ensure the job runs "once a day after business hours," the Schedulable interface is required. The developer allows the class to be scheduled via the Apex Scheduler or the UI.

The standard pattern for this use case is to create a class that implements Schedulable, and inside its execute method, instantiate and execute the Batch class (Database.executeBatch). This combines precise timing with bulk processing capabilities.

18

In the Aura Component framework, communication between components is handled via events. When two components need to communicate but do19 not share a direct parent-child relationship—such as a kiosk registration component on a page and an alert component residing in the global utility tray—an Application Event (Option C) is required.

Application events follow a "publish-subscribe" model. One component fires the event, and any other component in the application that has a handler for that specific event type can listen for and react to it, regardless of where they sit in the component hierarchy. This is distinct from a Component Event (Option D), which is restricted to bubbling up the component containment hierarchy (from child to parent).

While modern implementations might also consider the Lightning Message Service (LMS) for cross-framework communication (between Aura, LWC, and Visualforce), within the specific context of Aura-to-Aura communication for decoupled components like utility bar items, Application Events remain the fundamental architectural solution. DML Operations (Option A) and ChangeLogs (Option B) are database-level concepts and do not provide the real-time, client-side notification capabilities needed for a UI alert system.

==========

For AppExchange development, Custom Metadata Types (Option C) are the superior choice for application configurations. Unlike Custom Settings or Custom Objects, Custom Metadata records are treated as metadata, not data.

This provides three critical advantages for an AppExchange developer:

Packaging and Deployment: You can package the metadata records (the "best practice settings") as part of your managed package. When a customer installs your app, these settings are automatically populated in their org.

Environment Consistency: Custom Metadata can be deployed across sandboxes and production using standard deployment tools (Change Sets, CLI), whereas Custom Settings require manual data migration or data loading in every new environment.

Unit Testing: Apex tests can access Custom Metadata without the need for (SeeAllData=true). This ensures that your package's logic remains testable and robust across all subscriber orgs regardless of their specific data setup.

Custom Labels (Option D) are intended for translated text, not complex logic triggers. Custom Objects (Option B) consume data storage and cannot be easily packaged with default records. Custom Metadata allows the app to be "configurable" by the subscriber while providing a "standard" baseline upon installation.

In Large Data Volume (LDV) environments, Salesforce uses the Query Optimizer to determine if a query can use an index. A query is "selective" if it filters the records using an indexed field and reduces the result set to less than 10% of the first million records.

Option A is highly selective. The Id field is the primary key and is always indexed. Filtering by a list of IDs is the most efficient way to query records because it allows the database to perform a direct index lookup.

Option B is selective because it filters on the Name field (which is a standard indexed field) and Customer_Number__c. In the context of PDII, a field like "Customer Number" is typically marked as an External ID, which automatically creates a custom index. Even without the second filter, the IN clause on an indexed field like Name makes the query selective.

Option C is non-selective because negative filters (using !=) and "not null" checks generally force the database to perform a full table scan. Option D is non-selective because it uses a leading wildcard (%Partner). While the Name field is indexed, the index cannot be used if the search string starts with a wildcard, as the database must inspect the end of every string in the table.

48

Platform Events provide a powerful way to integrate Salesforce with external systems using an event-driven architecture. To meet the requirement of notifying an external system abo49ut an exception, the developer must first define a Custom Platform Event (e.g., Error_Event__e). In the Apex code, specifically within a catch block, the developer should instantiate this event and publish it using the EventBus.publish() method (Option A).

Once published, the event is placed on the event bus. External systems can listen for these events by subscribing to the event channel. The standard protocol for external clients to subscribe to Salesforce Platform Events is CometD, an implementation of the Bayeux protocol that allows for long-polling and real-time push notifications.

Option B and C are incorrect because addError() is a method used in triggers or Visualforce to display a validation error message to the UI and roll back the transaction; it is not used for publishing Platform Events. Option D is incorrect because an external system cannot receive an event unless the Salesforce application explicitly publishes it to the bus. Using EventBus.publish() with a CometD subscriber provides a robust, decoupled integration pattern for real-time error reporting.

When a requirement involves storing configuration or "secret" data that needs to vary based on the specific user or profile, Hierarchy Custom Settings (Option C) are the correct choice. Unlike Custom Metadata (Option B), which is available to the entire organization regardless of the user, Hierarchy Custom Settings use a built-in logic to provide values based on the "most specific" level defined.

The hierarchy follows a specific order: User > Profile > Organization. If a secret key is defined at the User level, that value is returned for that specific user. If not, the system looks for a value defined at the user's Profile level, and finally falls back to the Organization-wide default. This allows a developer to store sensitive keys or flags and restrict or vary them dynamically based on the current user's identity.

Custom Metadata is better suited for application-wide configurations that need to be deployable via packages, but it lacks the granular per-user/per-profile override capability inherent to Hierarchy Custom Settings. Static Resources (Option A) are public to anyone with access to the resource, and Cookies (Option D) are stored on the client side, making them insecure for "secret" data. Therefore, Custom Settings provide the best balance of security and hierarchical flexibility for this use case.

==========

To perform historical auditing and analysis of user behavior—such as tracking the last login time—Salesforce provides Event Monitoring (Option C). This feature captures a wide range of "Event Types," including logins, logouts, URI (page) clicks, and API calls.

These events are stored in EventLogFile objects. Each day, Salesforce generates log files for the previous day's activity. A developer can query these files or use tools like the Salesforce Event Log File Browser to see a comprehensive history of user logins. This is the correct choice when real-time alerts are not necessary and the goal is to analyze patterns over time.

Option A refers to Change Data Capture, which is for tracking record changes, not user sessions. Option B is for the standard Salesforce Calendar. Option D (Developer Log) is used for debugging Apex and system execution in the short term and does not provide a reliable or long-term history of user login events. Event Monitoring provides the high-fidelity audit trail required for compliance and security analysis.

Salesforce enforces a strict architectural boundary regarding database transactions and external communications. When an Apex trigger executes, it is part of a synchronous database transaction. If the platform allowed a synchronous callout (a web service call) directly from a trigger, the database transaction—including all active record locks—would have to remain open while waiting for the external system to respond. This could lead to severe performance degradation and hit the "Concurrent Request" limit.

Consequently, calling a web service from an Apex trigger (Option C) must be handled asynchronously. A developer must hand off the callout logic to an @future(callout=true) method, a Queueable class, or a Platform Event. This allows the trigger to finish its work and commit the database transaction immediately, while the callout runs in its own separate background process with its own set of governor limits.

Option A is incorrect because a standard synchronous query can retrieve up to 50,000 records. Option B is incorrect because System.scheduleBatch is a synchronous call to initiate a process, even if the process itself runs later. Option D is incorrect because record updates can be handled synchronously in an after insert trigger context.