SF-PD2 Flashcards — Free Salesforce Certified Platform Developer II Study Cards

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

Wrapping the asynchronous invocation block inside Test.startTest() and Test.stopTest() forces all asynchronous calls queued within the block to execute synchronously before Test.stopTest() completes. This pattern is fundamental in Salesforce testing because it allows developers to reliably assert database states modified by future methods, batch apex, or queueable jobs, preventing false test failures caused by execution timing races.

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

Understanding event propagation in Lightning Web Components is vital for building scalable architectures. When an event needs to cross the shadow DOM boundary and continue bubbling up the regular DOM, both the bubbles and composed properties must be set to true. This allows the event to reach components outside of the immediate shadow root where it originated, enabling decoupled communication between distant components.

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

Governor limits enforce boundaries on DML statements within a single transaction to ensure platform stability. Performing DML inside a loop is a violation of best practices because each statement counts against the limit. Refactoring the code to collect records in a list and performing a single DML operation outside the loop reduces the number of statements from 5,000 to one, ensuring the code remains scalable and efficient for large datasets.

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

Queueable Apex implementing Database.AllowsCallouts is the optimal choice for asynchronous HTTP callouts in Salesforce. It supports chaining jobs, passing complex data types as member variables, and provides robust error handling compared to future methods. Mastering asynchronous processing patterns ensures application resilience and prevents governor limit violations during high-volume enterprise integrations.

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

The HttpCalloutMock interface is the standard way to handle external requests in tests. Since Apex unit tests are prohibited from making actual network calls, implementing this interface allows developers to define a static response. This pattern is essential for creating deterministic tests that verify how code handles both success and failure scenarios without requiring an external service to be active or reachable.

The transaction failed because the CPU time exceeded the 10,000 ms limit.

The debug log shows the cumulative limit usage at the end of a transaction. The 'Maximum CPU time' entry indicates that 10,005 milliseconds were used, which exceeds the synchronous governor limit of 10,000 milliseconds. This results in a LimitException, and the transaction is rolled back, regardless of how many queries or rows were processed.

Check field values in the trigger to avoid redundant logic. / Move business logic into a separate service class. / Use the 'if' condition to exit early if criteria are not met.

Trigger optimization is essential for preventing unnecessary processing. By checking if fields have actually changed, the developer avoids executing logic when no relevant data updates have occurred. Furthermore, decoupling logic into service classes keeps the trigger thin and manageable, while early-exit patterns ensure the code finishes as fast as possible if conditions aren't met, maintaining high system throughput and preventing governor limit issues.

It centralizes credential management and prevents hardcoded secrets.

Named Credentials encapsulate the authentication process and the endpoint URL, separating the integration configuration from the source code. This not only makes the code cleaner but also provides centralized management of sensitive credentials. If credentials expire or the endpoint changes, the developer updates the Named Credential object, and all associated integrations are updated simultaneously without requiring a deployment or code change.

Salesforce Developer Console Log Inspector

The Developer Console includes a powerful execution log inspector and perspective layout specifically designed for tracing Apex transactions. Debug logs record database queries, heap allocations, and method entries, enabling developers to isolate root causes of unexpected runtime behaviors efficiently during active troubleshooting sessions.

Wrap the test logic in Test.startTest() and Test.stopTest().

Using Test.startTest() and Test.stopTest() is the only supported way to force asynchronous code to execute synchronously within a test block. Any asynchronous jobs added between these two calls are processed when stopTest() is invoked. This pattern ensures that tests can assert the outcome of background operations, which is crucial for testing complex integrations or batch processes that rely on asynchronous execution.

Create a new user within the test method and use System.runAs().

Tests must create their own data, including Users, to ensure they remain self-contained and environment-independent. Using the 'RunAs' method in combination with user creation allows the developer to simulate specific security and permission contexts. This ensures that the logic is tested exactly as it would be for the target user, confirming that the code respects the platform's security model consistently.

Hierarchy Custom Setting.

Custom Settings are categorized into List and Hierarchy types. Hierarchy Custom Settings allow developers to define values at the Organization, Profile, or User level. This provides a flexible mechanism to retrieve environment-specific configurations without the overhead of SOQL queries, which count against governor limits. For per-profile configuration, the Hierarchy type is the standard architectural choice in Salesforce development.

{ bubbles: true, composed: true }

Custom events in Lightning Web Components require the bubbles and composed properties to be set to true when they need to cross shadow DOM boundaries and propagate up through the entire DOM tree, including parent and grandparent components. Setting composed to false restricts the event strictly within the local shadow tree of the component that dispatched it.

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

Implementing the Database.Stateful interface in a Batch Apex class ensures that instance member variables retain their values across distinct transaction chunks. Without this interface, member variables reset between execute method invocations. Preserving state is essential for maintaining running totals and aggregate metrics during large-scale data processing.

Replace nested loops with Map-based lookups.

The CPU time limit is reached when the Apex code performs too many calculations, loops, or complex logic within a single transaction. Optimization requires reducing the complexity of the code, such as moving away from nested loops, using maps for faster lookups, or offloading heavy computations to asynchronous processes like Batch Apex or Queueable Apex. This ensures that the transaction completes within the time limit allocated by the platform.

Apply custom indexes on frequently filtered fields and ensure filters use selective criteria.

Utilizing selective queries with custom indexes combined with proper bind variables ensures that database operations avoid full table scans. This optimization directly prevents CPU time and query row limit exceptions, protecting platform resources and maintaining user experience under heavy transaction loads.

Increase the debug log level for the user executing the deployment.

Effective debugging starts with ensuring the logging level is correctly configured. If logs are not capturing the flow, it is likely the log level for 'Apex Code' or 'Apex Profiling' is set to 'None' or 'Error'. Increasing the verbosity to 'Fine' or 'Finest' is the standard procedure to gain visibility into the execution path, allowing for the identification of logic errors or incorrect configuration.

Use Queueable Apex to offload complex tasks to the background.

Asynchronous processing, such as Queueable Apex, offloads heavy tasks to the background. By executing long-running logic outside the main user request thread, the UI remains responsive. This improves the perceived performance of the application significantly, as users do not have to wait for complex computations to finish before continuing their work in the Salesforce interface.

req.setHeader('Content-Type', 'application/json');

To successfully communicate with an external API that expects specific metadata, the HTTP request must be configured with the necessary headers before the request is sent. The HttpRequest class provides the setHeader() method, which is the standard way to define metadata such as 'Content-Type' or 'Authorization'. Adding this line ensures the request is formatted correctly for the external system's expectations.

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

Using relationship queries (joins) allows fetching data from parent and child objects in a single SOQL statement. This prevents the 'query-in-a-loop' anti-pattern, which is the most common cause of hitting the 100 SOQL query limit. By retrieving all necessary data at once, the developer reduces the number of server round-trips and keeps the transaction lightweight and performant, which is essential for scaling code in an enterprise environment.

Use Platform Events to log the data asynchronously in a separate transaction.

Using a Platform Event to log integration data is the most efficient pattern. Because the logging happens asynchronously, it doesn't block the main business transaction. By publishing an event, a separate subscriber can handle the heavy lifting of storing the log in a custom object, ensuring the primary business operation remains performant while maintaining an audit trail for all outbound communications.

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.

Integrating CI/CD pipelines with version control hooks automates validation processes. Utilizing Salesforce CLI commands within CI runners guarantees that code meets quality gates and test coverage thresholds before merging into shared branches, protecting code health and reducing integration debt across large distributed development teams.