SF-PD2 Performance — 15 Questions

Question 1

A developer needs to query a high-volume custom object with millions of records. The query often results in 'Non-selective query' errors. Which TWO techniques should the developer implement to ensure the query remains performant?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Ensure the WHERE clause filters on indexed fields, such as Id or External ID.. Non-selective queries occur when the database engine performs a full table scan rather than leveraging an index. To avoid this, developers must ensure that filters use indexed fields. If an index is not available, creating a custom index via Salesforce support or using external IDs is necessary. Additionally, keeping the result set small through selective filtering and avoiding leading wildcards in LIKE operators prevents resource-intensive processing that causes timeouts.

Answer

Include a leading wildcard in the LIKE clause of the WHERE filter.

Answer

Use the FORCE_INDEX hint in the SOQL query string.

Answer

Increase the heap size limit by using Apex System.Limits.

Question 2

Refer to the exhibit. The query is failing on an object with 15 million records. Why is this occurring and how can it be fixed?

Accepted Answer

Add a secondary filter on an indexed field to increase selectivity.. The query fails because CreatedDate is not indexed by default on large objects in the same way as Id, and the result set exceeds the threshold for non-selective queries. To resolve this, the developer must ensure the filter uses an indexed field. If filtering by date is mandatory, creating a custom index on that field or narrowing the filter to a more selective range is required to prevent a full table scan.

Answer

The query limit is too high; reduce it to 10,000.

Answer

Convert the query to use the REST API instead of Apex.

Answer

Wrap the query in a try-catch block to ignore the error.

Question 3

A developer is analyzing a slow-performing Visualforce page that displays a complex table. Which THREE areas should the developer investigate to improve performance?

Accepted Answer

Reduce the size of the page view state.. Visualforce performance is often hampered by excessive view state, inefficient controller logic, and poor data retrieval patterns. Investigating these three areas helps minimize the amount of data transferred to the client, reduces the processing time per request, and ensures that the page remains responsive even when handling large datasets or complex user interactions, which is essential for maintaining a positive user experience.

Answer

Enable 'Debug Mode' for all users to track issues.

Answer

Increase the maximum number of view state variables.

Question 4

A developer has an LWC that updates records frequently. What is the best way to ensure UI responsiveness while performing server-side updates?

Accepted Answer

Use 'await' with imperative calls and show a spinner.. Using the @wire service or the imperative call with a loading state ensures the UI remains responsive while the server processes the data. By not blocking the main thread and providing visual feedback, the user experience is maintained. Additionally, utilizing optimistic UI updates allows the interface to reflect the change immediately before the server confirmation arrives, making the application feel faster and more reliable to the user.

Answer

Block the UI using a modal until the update completes.

Answer

Refresh the entire page after every update.

Answer

Perform the updates synchronously in the browser.

Question 5

A developer is writing a batch class that processes millions of records. Which strategy should be used to ensure the class remains stable under high load?

Accepted Answer

Use the Database.getQueryLocator to handle large datasets.. To ensure stability when processing millions of records, the developer must minimize memory usage and avoid transaction bottlenecks. Using a custom 'Iterable' allows the developer to control exactly how records are loaded, while ensuring the 'start' method returns a query locator or iterable that is highly efficient. Batching with a small size prevents heap exhaustion, and proper error handling ensures that one failed batch does not crash the entire million-record operation.

Answer

Set the batch size to 2000 to maximize throughput.

Answer

Perform all processing within the 'start' method.

Answer

Clear the heap manually using System.gc().

Question 6

An enterprise Salesforce application requires high-volume inserts of custom object records from an external system. Developers notice significant database contention and lock errors during parallel batch processing. Which approach should a developer implement to minimize record locking and maximize performance?

Accepted Answer

Sort the incoming record list by parent record IDs prior to insertion to ensure consistent processing order.. Minimizing record locking during high-volume parallel inserts requires careful handling of parent records and avoiding operations that lock shared tables. Processing parent records in a predictable, sorted order before child creation reduces deadlocks. This pattern is critical for large-scale data migrations and integrations to ensure thread safety and optimal throughput.

Answer

Disable all triggers and validation rules globally via setup before initiating the bulk data load.

Answer

Execute the insert operations inside a single large transaction using Database.insert with allOrNone set to false.

Answer

Increase the batch size in the Bulk API configuration to the maximum limit of 10,000 records per batch.

Question 7

An organization experiences slow performance when querying large custom objects. Which TWO indexing strategies should the developer implement to improve SOQL query performance?

Accepted Answer

Mark the frequently queried field as an External ID.. Custom indexes and external IDs are essential for optimizing SOQL performance in large datasets. By indexing fields frequently used in WHERE clauses, the query optimizer can perform a targeted index lookup rather than a full table scan. This minimizes the I/O load, reduces CPU time, and ensures queries remain performant as the data volume continues to grow over time.

Answer

Use wildcard characters at the beginning of filter strings.

Answer

Increase the batch size in the SOQL query to 5000.

Answer

Remove all indexes from the object to reduce storage overhead.

Question 8

Which action should a developer take when they find that their Lightning Web Component (LWC) is re-rendering too frequently, causing UI performance issues?

Accepted Answer

Implement the Memoization pattern for data retrieved from Apex.. Frequent re-rendering often stems from unnecessary state changes or inefficient data binding. By using the @track decorator properly and ensuring that public properties are updated only when data actually changes, the developer can prevent the framework from triggering the reactive lifecycle more often than necessary. This ensures a smoother user experience and reduces the memory footprint of the component in the browser.

Answer

Use the connectedCallback() method to trigger manual DOM updates.

Answer

Increase the window.setTimeout delay for property updates.

Answer

Force an update by calling the render() method explicitly.

Question 9

Refer to the exhibit. The query is causing a 'Too many query rows' error during processing. What is the best way to handle this data set?

Accepted Answer

Use Batch Apex with Database.getQueryLocator to process records.. The query is hitting the heap size or query rows limit due to the volume of returned data. By using the 'Query Locator' pattern in a Batch Apex class, the developer can process records in smaller chunks of up to 50,000 records per scope. This allows the system to handle millions of records without exceeding memory or row limits, ensuring the process remains robust and stable.

Answer

Increase the query limit in the SOQL statement to 100,000.

Answer

Convert the query into a nested loop to process one account at a time.

Answer

Move the query result into a Static variable to reuse across transactions.

Question 10

A developer needs to store temporary data during a transaction. What is the most memory-efficient way to handle this?

Accepted Answer

Use a Map for temporary data to allow for O(1) lookup.. Using a Map collection allows for efficient, O(1) lookups and minimizes the memory footprint compared to large, unorganized lists. By storing only the necessary fields and using proper scoping, the developer avoids unnecessary heap allocation. This helps keep the application within the governor limits for heap size, which is vital when dealing with large data volumes in a single Apex transaction.

Answer

Store all records in a List and iterate over it repeatedly.

Answer

Create custom objects to store temporary data.

Answer

Use static variables to store data across the entire organization.

Question 11

Refer to the exhibit. A developer runs the provided SOQL query on an Account table containing 10 million records, but the query fails with a non-selective query exception. How should the developer modify the schema and query to resolve this performance issue?

Accepted Answer

Request Salesforce Customer Support to create a custom index on Custom_External_Id__c and ensure it is populated.. Creating a custom index on Custom_External_Id__c enables the query optimizer to evaluate the filter selectively. Because Standard System fields like CreatedDate are indexed automatically only under specific low-cardinality thresholds, explicitly indexing custom fields ensures high selectivity for large data volumes.

Answer

Remove the CreatedDate filter and rely entirely on the Custom_External_Id__c field filter.

Answer

Rewrite the query using an OR operator instead of AND to broaden the search criteria scope.

Answer

Wrap the query execution inside a Batch Apex class with a scope size of 1.

Question 12

An enterprise application needs to query over two million Account records daily to sync with an external warehouse. Developers are noticing high CPU time and database timeouts when executing standard SOQL queries. Which strategy best optimizes the SOQL query performance for large data volumes?

Accepted Answer

Implement PK Chunking natively via the Bulk API to automatically divide the query into parallel streams based on record IDs.. Optimizing large volume data extraction requires leveraging PK Chunking to bypass standard query result limits and reduce database locking contention. This native Salesforce mechanism splits large tables into parallel chunks based on primary keys, enabling external tools or custom batch jobs to process records efficiently without causing heap size issues or transaction timeouts.

Answer

Use standard SOQL queries with an OFFSET of 2,000 in a recursive queueable job to paginate through the large dataset.

Answer

Write an Apex trigger that caches all two million records into custom platform cache partitions prior to extraction.

Answer

Execute a single SOQL query without filters and iterate over the entire result set using an asynchronous batch apex stateful class.

Question 13

A developer is troubleshooting a custom Visualforce page that renders sluggishly for users who belong to roles near the top of a massive role hierarchy. The page queries custom objects that utilize private sharing models. Which performance tuning technique directly mitigates sharing recalculation overhead during query execution?

Accepted Answer

Utilize custom indexes requested through Salesforce Support and ensure WHERE clauses contain selective filters on standard fields.. Enabling Force.insecure or executing queries using WITH USER_MODE or WITHOUT SHARING appropriately can bypass unnecessary sharing evaluation when user context allows. However, the most robust architectural pattern involves leveraging custom indexes and writing selective queries that incorporate indexed standard fields, combined with judicious use of stripInaccessible or specific sharing keywords to avoid expensive runtime sharing calculation evaluations during heavy rendering cycles.

Answer

Wrap all underlying database operations within a class declared with the WITHOUT SHARING keyword to disable sharing evaluation entirely.

Answer

Refactor the controller to execute queries using the WITH SYSTEM_MODE clause to eliminate sharing evaluation overhead.

Answer

Convert the Visualforce page into a Lightning Web Component utilizing unCached wire adapters for all database calls.

Question 14

A developer is writing a SOQL query to retrieve records from a custom object named 'Service_Ticket__c' which contains 5 million records. The query must filter by 'Status__c' and 'Resolution_Date__c'. During testing, the query occasionally fails with a 'Query Exception: Non-selective query' error. What is the most efficient way to ensure the query remains selective?

Accepted Answer

Request a custom index from Salesforce Support on the 'Status__c' and 'Resolution_Date__c' fields.. Selective SOQL queries are critical for performance when dealing with Large Data Volumes (LDV). A query is selective when it uses an indexed field in the WHERE clause and the filter returns a limited percentage of the total records. This prevents the Query Optimizer from defaulting to a full table scan, which would otherwise lead to timeout errors and degraded performance across the multi-tenant environment.

Answer

Use the 'LIMIT' keyword to restrict the result set to under 50,000 records.

Answer

Change the query to use the 'OFFSET' clause to paginate through the large record set.

Answer

Wrap the SOQL query in a Try-Catch block to handle the exception gracefully at runtime.

Question 15

An organization processes large volumes of daily transaction data using Batch Apex. Recently, the batch jobs have been hitting the 10-second CPU time limit. Each transaction involves complex calculations and multiple DML operations on related objects. Which strategy should the developer implement to optimize the CPU usage of the batch job?

Accepted Answer

Reduce the batch scope size to a smaller number, such as 50 or 100 records per chunk.. Batch Apex provides high throughput, but each transaction is still bound by governor limits. Reducing the scope size is the most effective way to lower the CPU time per transaction. Smaller scopes ensure that the complex logic and DML operations performed in the execute method stay within the 10-second limit, allowing the job to complete successfully across many chunks.

Answer

Implement the Database.Stateful interface to maintain the state across all execution chunks.

Answer

Increase the batch size to 2,000 to process more records in fewer execution transactions.

Answer

Move the complex calculations into a @future method called from the batch execute method.