CCNA Performance Questions

Bulkification is the core design pattern for Salesforce development. Moving DML outside the loop ensures that only one DML statement is used regardless of the number of records, which completely eliminates the 'Too many DML statements' error and makes the code scalable and highly performant.

Loading 10,000 records at once overwhelms the browser and the network, causing slow rendering and freezes. Pagination or infinite scrolling limits the number of records loaded and displayed at a time, reducing memory usage and improving responsiveness. This is a standard performance optimization for large data sets in Lightning Web Components.

The CPU timeout occurs during execution, not querying. Inefficient code in the execute method, such as nested loops, multiple DML statements per record, or complex calculations, can consume excessive CPU time. With 2 million records, even small inefficiencies are amplified. Optimizing the execute method is the correct fix.

Pagination reduces the amount of data transferred in a single call, lowering heap usage and improving load times. The LWC can request pages on demand, providing a better user experience. This approach avoids hitting heap size limits and is a standard pattern for handling large datasets in Lightning.

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.

Moving the SOQL query outside the loop and storing results in a Map is a best practice for bulkification. It reduces the number of queries to one, regardless of the number of records processed. The Map allows efficient lookup of existing records by a key, such as a unique field, avoiding repeated database calls within the loop.

StandardSetController supports pagination and reduces the number of records loaded and rendered at once. This decreases view state size and improves page load time. It is a standard approach for handling large data sets in Visualforce without major UI changes.

Creating a custom index on the field used in the WHERE clause makes the query selective by allowing the database to quickly locate matching records. This reduces the number of records scanned and improves performance. Salesforce allows custom indexes on custom fields, which is a standard solution for non-selective queries on large objects.

Querying related records inside a loop results in multiple SOQL queries, leading to governor limit exceptions and slow performance. Each query adds overhead and can quickly exceed the 100 SOQL query limit. The correct approach is to use a single query with a relationship subquery or a separate query for all contacts and then map them to accounts in memory, avoiding the N+1 query problem.

The StandardSetController is designed for pagination. By setting the page size, the controller automatically handles fetching only the records needed for the current page, reducing the initial query load. This is the most efficient way to implement pagination with minimal custom code.

Using a Map to store parent Opportunity records allows the trigger to avoid querying inside a loop. The developer can query all necessary Opportunities once, populate a Map keyed by Id, and then retrieve parent records from the Map within the loop. This reduces the number of SOQL queries to one, improving performance and avoiding governor limits.

The log explicitly states that the Maximum CPU time was 10,005 milliseconds, which is over the 10,000 ms synchronous limit. The '*CLOSE TO LIMIT*' or actual exceeding of the number causes a LimitException. This means the code spent too long executing logic, loops, or transformations, causing the platform to terminate the request.

Querying all related child records in one SOQL query outside of any loop is the bulkified approach. It avoids the N+1 query problem and stays within governor limits. The trigger can then iterate over the retrieved records to perform necessary updates, ensuring efficiency and scalability.

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.

A single SOQL query that uses a WHERE clause with an IN binding on the trigger's Opportunity IDs (e.g., 'WHERE OpportunityId IN :oppIds') retrieves all necessary child records in one call. This respects the governor limit of 100 SOQL queries per transaction and is the standard bulkification pattern.

When two batch jobs or processes attempt to update the same records concurrently, row-level locks are held, leading to `UNABLE_TO_LOCK_ROW` errors and longer runtimes. The default batch size of 200 is not inherently problematic. The scenario indicates concurrent access, which is the most plausible cause of the locking and slowdown.

Collecting all AccountId values from Trigger.new and performing one SOQL query to retrieve the related Accounts is the best practice for bulkification. Using a Map to relate Accounts to Cases allows efficient updates without additional queries. This approach ensures the trigger can handle up to 200 records within governor limits, reducing the number of queries to one.

Apex callouts cannot be rolled back, so the safest pattern is to make the callout first, then wrap the DML in a savepoint and roll back if the write fails. This prevents partial data from being committed when the external response is unusable. It also keeps the callout outside any open savepoint scope, which is required because a callout after uncommitted DML in the same transaction causes a System.CalloutException.

Unindexed fields force a full table scan. In objects with millions of records, this is extremely slow. When the field also has high cardinality, the query optimizer cannot easily narrow down the results, leading to significant delays as the engine parses every single record in the object table.

A getter is invoked repeatedly during Visualforce rendering, so placing the query inside it causes redundant database calls. Moving the query to the constructor executes it once per request and caches the result in a member variable. This reduces query count, avoids repeated database work, and directly addresses the slow page load while preserving the displayed related list.

Deduplicating records with a Map ensures that each record is processed only once, reducing the number of DML operations and avoiding errors like duplicate updates. This is especially important when the same record might be updated multiple times in a loop. Combining deduplication with bulk DML further optimizes performance by minimizing the data processed.

Bulkifying the query by using a Set of IDs allows for a single SOQL statement. Storing the results in a Map provides O(1) time complexity for subsequent record lookups, which is significantly more efficient than nested loops or repeated database queries within the execution context.

This approach eliminates redundant queries by fetching all Contacts in a single query and then using a Map keyed by AccountId to efficiently associate them with each Account. It reduces the number of SOQL queries from potentially thousands to one, avoiding governor limits and dramatically improving page load time.

A single SOQL query with a subquery (e.g., SELECT Id, Name, (SELECT Id, Name FROM Contacts) FROM Account) retrieves all parent and child records in one query, reducing the number of queries to 1. This is efficient and well within governor limits, as the subquery counts as part of the same query. It avoids the N+1 query problem and is a standard performance optimization for related data.

Change Data Capture publishes events when records change, allowing a subscriber to process each new record and update a summary object incrementally. This avoids running a heavy aggregation query and keeps statistics up-to-date in near real-time, well within the 5-minute window. It is scalable and efficient for high-volume data.

StandardSetController provides built-in pagination, allowing the page to display a subset of records at a time. This reduces the initial query size and the amount of data rendered, significantly improving load time. It also handles sorting and navigation efficiently, making it ideal for large data sets in Visualforce.

Smaller batch sizes reduce the number of records processed per execute transaction, which lowers heap consumption and CPU time per chunk and makes it less likely that an individual transaction exceeds limits. It also lets the job recover more gracefully because only one batch fails if an error occurs, rather than the entire chunk. The trade-off is more transactions, but for heap-bound jobs this is often the right lever.

StandardSetController supports pagination through its setPageSize method and navigation methods like next() and previous(). Setting a smaller page size reduces the number of records rendered per page, improving load time. This is the intended use of StandardSetController for paginated data display in Visualforce, and it efficiently manages record retrieval.

Filtering on fields of related objects can cause the query optimizer to perform a full scan if the relationship is not appropriately indexed. This results in slow execution times as the engine checks millions of records to determine which meet the 'Technology' industry criteria on the parent.

Bulkifying the SOQL query by moving it outside the loop and using a Map to associate related records with the trigger records is the standard best practice. This reduces the number of queries to one, avoiding governor limits and improving performance.

A single query with a subquery (e.g., 'SELECT Id, Name, (SELECT Id, LastName FROM Contacts) FROM Account') retrieves all necessary data in one call. This eliminates the N+1 query problem, reduces database round trips, and avoids the SOQL query limit. The developer can then map Contacts by AccountId for efficient rendering in the Visualforce page.

Returning only the page of records the user needs drastically shrinks the JSON payload sent over the wire and the number of DOM nodes the component must render, which is the dominant cost. Marking the method cacheable allows the client-side Lightning Data Service cache to serve repeat requests without a server round trip, further improving perceived performance for read-only data.

One of the primary performance advantages of skinny tables is that they exclude records in the Recycle Bin. In a standard table, the database must filter out soft-deleted records during a query. By omitting these records entirely, skinny tables allow the database to scan a smaller, more relevant dataset, improving speed.

Bulkifying DML operations by collecting records into a list and performing one update statement after the loop is a best practice. This approach minimizes the total number of DML statements used per batch execution, staying well within governor limits and significantly improving overall processing time.

Sorting by ID ensures that all threads or processes lock records in the same order, which is the standard technique for preventing deadlocks and row locking contention in Salesforce. This approach is highly recommended when handling large-scale data updates to ensure the stability and reliability of the integration.

A single SOQL query with a subquery eliminates the N+1 query problem, drastically reducing database round trips and governor limit consumption. For 200 accounts, one query returns all related opportunity data, which can be processed in memory. This is the most efficient approach and aligns with Salesforce best practices for bulk data retrieval.

Keyset pagination uses a WHERE clause with the last seen Id (e.g., WHERE Id > :lastId ORDER BY Id LIMIT 200) to fetch the next set of records. This leverages the indexed Id field and avoids scanning skipped rows, making it efficient even for large datasets. It reduces data transfer and processing per request, directly addressing the timeout issue.

Using a relationship query (e.g., SELECT Id, Name, Owner.Name FROM Opportunity) in the StandardSetController's query retrieves the Owner's Name in the same query as the Opportunities. This eliminates the need for additional queries for each Opportunity, reducing the total number of queries and improving page load time. It is the most efficient way to fetch related data.

Marking a read-only Apex method cacheable and consuming it through @wire lets Lightning Data Service cache the response on the client. When the user returns to the tab, the cached data can be reused instead of issuing a new server call, which reduces redundant round trips. Cacheable methods must not perform DML, which fits the read-only requirement.

Session Cache stores data that is tied to a specific user's session. It is the correct choice for this scenario because it allows the developer to cache the results of expensive calculations only for that user. This ensures that the data is reused across multiple requests by the same user, improving their specific experience.

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.

Using `StandardSetController` with pagination reduces the number of records retrieved and rendered at once, decreasing view state size and improving load time. It also helps avoid hitting governor limits by processing smaller batches. This is a standard best practice for handling large data sets in Visualforce.

Comparing the old and new field values is a crucial optimization step. It prevents the trigger from running expensive logic when no relevant fields have been modified, effectively reducing the CPU usage and ensuring the code remains performant for bulk operations where only a few records might change.

Performing DML inside a loop causes multiple database operations, quickly hitting the DML governor limit (150 statements) and degrading performance. Collecting records in a list and executing one DML operation after the loop is the recommended bulkification pattern. This reduces database round trips and improves transaction speed.

Platform Cache serves data directly from memory, which is much faster than querying the database. By reducing the reliance on SOQL or API calls, it significantly decreases latency and CPU consumption, providing a seamless user experience even under heavy load, which is critical for performance-optimized Salesforce applications.

Selecting only the necessary fields reduces the amount of data transferred from the database to the Apex method and then to the client. Rich text and formula fields can be expensive to compute and transfer. By querying only the fields needed for display, the developer minimizes heap usage and improves response time. This is a best practice for optimizing SOQL queries.

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.

Custom indexes allow the database query engine to instantly locate record subsets without scanning entire tables. When queries use selective filters matching indexed fields, database statistics optimize execution paths, drastically reducing query execution times and preventing timeout errors.

Batch Apex allows up to 200 SOQL queries per transaction. If the execute method queries inside a loop, it can quickly exceed this limit. Moving the query outside the loop and using a Map to correlate records is the standard fix. This bulkifies the code and prevents governor limit errors.

Queueable Apex provides a robust way to chain and monitor asynchronous jobs. It is more flexible than @future methods and is the recommended approach for offloading non-critical, long-running operations, keeping the UI responsive while ensuring the backend work is completed reliably and in the correct order.

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.

SOQL queries rely on indexes to efficiently filter records. If the WHERE clause references a field without a custom index, the query performs a full table scan, consuming excessive CPU time. This is especially problematic in triggers where CPU limits are strict. Adding a custom index on the filtered field can dramatically improve performance and prevent CPU time exceptions.

SOSL is designed for searching multiple objects simultaneously by utilizing pre-built indexes on text fields. It is significantly faster than executing individual SOQL queries, especially when the search scope spans several objects, making it the standard choice for building efficient, high-performance search features in Salesforce.

Querying the related child records once before the loop, storing them in a Map keyed by the parent relationship Id, and then iterating Trigger.new against that Map removes the per-record query from the loop. This keeps the code bulk-safe, avoids hitting the 100 SOQL query governor limit, and scales to 200-record batches without additional DML or query overhead.

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.