SF-PD2 Exam Questions and Answers

Enclose the future method invocation between Test.startTest() and Test.stopTest() to force synchronous execution.

Test.startTest resets governor limits and establishes a new context where asynchronous requests are held until Test.stopTest processes them synchronously. This guarantees that all queued future jobs finish executing before subsequent assertions run in the test method.

Salesforce Developer Console Log Inspector

The Log Inspector provides detailed hierarchical views of execution logs, heap sizes, and database events. It allows developers to step through checkpoints and analyze memory usage, making it the primary built-in utility for deep Apex debugging.

Set up a CI/CD pipeline using GitHub Actions or Jenkins to spin up a scratch org, push metadata, and run sf apex test run.

CI/CD tools execute headless shell scripts triggered by git push events. Running Salesforce CLI commands inside pipeline agents allows teams to create temporary scratch orgs, deploy code changes, execute tests, and enforce quality gates automatically.

Examine the detailed deployment error logs to identify the failing test method or trigger logic, fix the root cause, and re-run validation.

Deployment errors wrapping trigger executions usually occur when automated unit tests run during deployment and hit unhandled exceptions. Analyzing the complete stack trace pinpoints the exact line of failure, allowing developers to correct data setup or trigger logic.

Create a data factory class to handle object creation and common test data scenarios.

Centralizing test data creation in a dedicated factory class promotes reusability and simplifies maintenance. When schema changes occur, you only need to update the factory rather than dozens of individual test classes. This pattern is a hallmark of professional Salesforce development and significantly reduces test suite fragility and technical debt.

Perform bulk testing by inserting a list of 200 records to verify governor limits.

Testing with a single record is insufficient because it fails to reveal potential SOQL or DML limit violations that only occur at scale. By inserting a batch of 200 records, developers ensure that their code handles Salesforce bulkification requirements correctly, preventing runtime errors in production when users perform mass operations.

The classes share a cyclic reference, preventing the compiler from determining the initialization order.

Apex classes cannot have direct circular references because the compiler must resolve all dependencies before successful class compilation. When Class A calls Class B and Class B calls Class A, the system cannot verify the types and methods during the build phase, resulting in the reported deployment failure.

new CustomEvent('update', { bubbles: true, composed: true });

Combining bubbles and composed properties ensures the event travels up the DOM and successfully exits the shadow DOM boundary. This is the standard approach for bubbling events to ancestors that are not direct parents, allowing the event to reach the document root or any listener registered on higher-level components.

@salesforce/i18n import statements

The @salesforce/i18n module provides access to locale-specific settings such as currency codes, date formats, and time zones. By importing these values, developers can use standard JavaScript Intl objects or framework utilities to format data correctly for every user, regardless of their geographical location or language settings.

Translation Workbench and Custom Labels

Custom Labels allow developers to store text strings that can be translated via the Translation Workbench. By referencing these labels in LWC via the @salesforce/label module, the framework automatically serves the version of the text that matches the user's language, facilitating easy multi-language support in the UI.

Use the getRecord wire adapter to retrieve Opportunity data.

The getRecord wire adapter is built on Lightning Data Service, which maintains a client-side cache. If any other component updates the Opportunity record using LDS, the wire service automatically triggers a refresh for all components observing that record, ensuring data consistency across the UI without requiring custom refresh logic.

Define <target>lightning__RecordPage</target> and use <objects> in <targetConfig>.

This configuration correctly identifies the Record Page as a valid target for the component. By further specifying the Account and Contact objects within the targetConfig section, the developer ensures that the component only appears in the App Builder palette when those specific record types are being edited.

Mark non-essential controller variables with the 'transient' keyword.

The transient keyword prevents a variable from being included in the Visualforce view state. This is highly effective for large collections or temporary data that only needs to exist during the current request. By reducing the view state size, the developer decreases the payload sent over the network.

The main JavaScript file in the 'utils' folder must be named 'utils.js'.

In LWC, the main JavaScript file of a component must have the exact same name as the folder it resides in. If the folder is named 'utils', the framework expects a file named 'utils.js'. If the file is named differently, the 'c/utils' import path will fail to resolve during the compilation process.

Collect records in a list and perform one DML statement after the loop.

Performing a single DML statement on a list of records is the standard pattern for bulkifying Apex code. This approach uses only one of the 150 allowed DML statements, allowing the transaction to handle larger record volumes efficiently while significantly reducing the load on the database engine.

Implement a Batch Apex class to update in chunks.

Batch Apex processes the 50,000 records in smaller, manageable chunks, typically 200 at a time. This keeps the execution within the governor limits for each batch, allowing the entire job to complete successfully without hitting the DML limit or exhausting the CPU time allocated to a single transaction.

Utilize the Composite API to batch multiple operations.

The Composite API allows developers to combine multiple SObject operations into a single request. This drastically reduces the number of API calls needed to sync large datasets, minimizing the impact on API limits and reducing the network latency associated with multiple round-trips to the Salesforce server.

Replace nested loops with Map-based lookups.

Nested loops are computationally expensive, with a time complexity of O(n*m). Replacing these with a Map allows for constant time O(1) lookups, which drastically reduces the CPU cycles required for data processing. This is the most effective way to optimize logic that is causing CPU limit issues.

Use a single relationship query to fetch parent and child records.

Relationship queries allow the retrieval of related data in one statement. This approach is highly efficient because it eliminates the need for repeated database calls, staying within governor limits and significantly reducing execution time compared to multiple individual queries performed in a loop or sequentially.

Use SOQL with GROUP BY to perform aggregation in the database.

Using the GROUP BY clause allows the database engine to perform the aggregation, which is highly optimized. This approach avoids transferring large volumes of data to the Apex heap, effectively preventing memory and CPU limit errors while providing the results in a much faster, more efficient manner.

Create a Queueable Apex class implementing Database.AllowsCallouts, leveraging custom retry logic and job chaining when a timeout occurs.

Queueable Apex supports complex object serialization, making it ideal for passing large payloads to external services. Implementing the Database.AllowsCallouts interface permits HTTP requests, and job chaining allows developers to implement sophisticated back-off and retry mechanisms safely.

Utilize Database.insert(records, false) and iterate through the returned Database.SaveResult array to identify individual failures and construct a detailed response payload.

Allowing partial success with Database.insert and evaluating SaveResult instances gives developers granular control over error handling. This pattern ensures valid records are persisted while exact failure reasons are captured and returned to the calling external system.

Serialize custom error DTO objects into the HTTP response body, mapping failed record IDs to specific error messages extracted from the SaveResult errors.

Returning a structured DTO payload containing specific record IDs and corresponding error messages allows the external client to reconcile its state. This level of transparency is essential for maintaining data synchronization between distributed enterprise systems.

Implement the Database.Stateful interface on the batch class definition to preserve instance member variable states across transaction chunks.

Database.Stateful preserves instance member variables between each executeBatch transaction, so running totals survive chunk boundaries. Without it, each batch reinitialises the class and accumulated values are lost, breaking the summary logging record update on completion.

Implement a Queueable Apex class with Database.AllowsCallouts, leveraging the Finalizer interface to capture failures and execute recovery logic.

Queueable Apex with Database.AllowsCallouts permits asynchronous callouts, while the Finalizer interface captures unhandled failures and runs recovery logic after a timeout. This satisfies both architectural constraints: asynchronous high-volume processing and robust error logging with recovery.

Global class with @RestResource(urlMapping='/api/v1/orders/*') and a static method annotated with @HttpPost receiving parsed wrapper instances.

A global class exposing @RestResource with a URL mapping, plus a static @HttpPost method accepting deserialised wrapper instances, lets Apex parse complex JSON including polymorphic types. Wrappers give explicit typed fields, which Apex requires because it cannot natively bind polymorphic JSON to a single concrete type.

Publish a Platform Event to an event bus for the ERP system to consume.

Platform Events facilitate an asynchronous, decoupled architecture where Salesforce publishes changes to the event bus. This approach ensures that the primary transaction completes quickly while the ERP system consumes events independently. This pattern is highly scalable and fault-tolerant, perfectly aligning with modern enterprise integration requirements for reliable system communication.

Using the System.Test.setMock() method with an implementation of HttpCalloutMock.

System.Test.setMock is the officially supported mechanism for intercepting HTTP requests during unit testing. By passing an instance of a class that implements the HttpCalloutMock interface, the developer instructs the Apex runtime to return a predefined HttpResponse object instead of initiating an actual network request to the endpoint.

Type.forName()

Type.forName() accepts a string representing the fully qualified name of an Apex class and returns a Type object. This Type object can then be used to call the newInstance() method, allowing for dynamic instantiation of the class at runtime, which is essential for flexible and extensible application design.

Using Named Credentials with an authentication provider.

Named Credentials provide a secure, standardized way to handle external callouts. They store the endpoint URL and authentication details (like OAuth tokens or API keys) centrally. This prevents hardcoding, centralizes credential management, and ensures that the platform handles the authorization headers automatically during the request lifecycle.

Implementing the Queueable interface.

Queueable Apex is the modern standard for asynchronous work. It allows for complex logic, supports stateful variables, and enables job chaining (calling one job from another). This makes it vastly more flexible and scalable than older patterns, while also providing a higher governor limit for processing large volumes of data.

Refactor the logic to collect IDs and execute a single SOQL query before the loop.

Executing a single query outside the loop allows the developer to store results in a Map. Inside the loop, the developer can then perform O(1) lookups. This pattern is the standard for bulkifying Apex code and ensures the total number of queries remains well below the limit of 100.

The code will fail with an exception if the ID does not exist.

When an SOQL query is assigned to a single SObject variable, Salesforce expects exactly one result. If zero results are returned, a runtime exception occurs. Using a List to query the data allows the developer to check if the list is empty before attempting an update, avoiding the crash.