Free Salesforce PDII Practice Exam with Questions & Answers

24

The Visualforc25e View State holds the state of the page (including controller variables) between server requests. It has a strict limit of 135KB. When a page handles large sets of data, like a grid of Opportunities, the view state can easily exceed this limit.

Transient Keyword (Option A): This is the most effective programmatic way to reduce view state. Marking a variable as transient prevents it from being serialized into the view state. This should be used for any data that is only needed for the current request and does not need to be maintained during a postback (e.g., large lists of records retrieved for a single display).

Filters and Pagination (Option D): By using a StandardSetController or custom offset logic, the developer can limit the number of records held in memory at any given time. Instead of loading 5,000 Opportunities, the page can load and store only 20 records per page.

Refine SOQL Queries (Option E): Developers often query "all" fields (e.g., SELECT * equivalent) or include large text areas that aren't displayed. By selecting only the specific fields required for the grid, the size of each object in the collection is reduced, directly lowering the view state.

Option B and C (private and final) affect variable visibility and immutability but do not prevent the variables from being serialized into the view state.

When a Visualforce page is slow because it attempts to load a massive dataset all at once, the bottleneck is often the time taken by the controller constructor to query and process those records before the page can even begin to render. Lazy Loading (Option B) is a strategy where the developer avoids loading all data during the initial page initialization.

Instead of querying 10,000 records in the constructor, the developer can load only the structural elements of the page first. Then, using an action method (triggered by <apex:actionFunction> or a window.onload script), the data is fetched in the background. This allows the user to see the page layout immediately while the data "populates" shortly after. This significantly improves the Time to First Byte (TTFB) and the perceived performance of the page.

Option A (transient) is excellent for reducing the View State size and speeding up postbacks (button clicks), but it does not inherently speed up the initial load time of a large dataset. Option C (JavaScript processing) can help but doesn't solve the data retrieval bottleneck. Option D (actionPoller) is used for periodic updates and is not an efficient way to load an initial large dataset. Lazy loading ensures that the "heavy lifting" is decoupled from the initial page load, providing a more responsive experience.

To make a Lightning Web Component (LWC) available for use in the Lightning App Builder, the developer must modify the component's configuration file (the .js-meta.xml file).

First, the isExposed tag must be set to true. By default, this is false, meaning the component is only available to other components within the namespace but not to the App Builder or Experience Builder. Setting it to true exposes it to the tools.

Second, the developer must specify where the component can be dragged and dropped by defining targets. Since the question states the component displays information about the "record in context," it implies the component is designed to live on a Record Page. Therefore, adding lightning__RecordPage is essential. While lightning__AppPage (Option D) is a valid target, the context of "record in context" strongly points to the Record Page target. There is no IsVisible attribute in the LWC configuration schema.

14

In Sales15force, SOSL (Search) queries behave differently than SOQL (Database) queries during unit tests. Because the search index is not updated in real-time during a test transaction, a SOSL FIND statement will consistently return an empty list, even if records matching the criteria were just inserted within the same test method. This leads to the assertion failure seen in the developer's code.

To overcome this, Salesforce provides the Test.setFixedSearchResults() method (Option C). This method allows a developer to define exactly which record IDs should be returned by any SOSL query executed during the test. When Test.setFixedSearchResults(list_of_ids) is called, the platform bypasses the actual search engine and returns the specified records. This ensures that the test remains deterministic and can verify the logic that processes the search results.

Option A (SeeAllData=true) is a poor practice and doesn't guarantee the search index will be ready. Option B (Test.loadData) and Option D (@testSetup) are for data creation but do not solve the underlying SOSL indexing limitation. Using setFixedSearchResults is the standard, documented way to test SOSL functionality in the Apex environment.

==========

67

Salesforce uses Database.Savepoint objects to manage transaction integrity, allowing developers to roll back the database state to a specific point in time without aborting the entire transaction. However, savepoints follow a strict "stack" logic.8 When you create savepoints in sequence (SP1, then SP2, then SP3), they exist in a linear timeline.91011

When a developer executes a Database.rollback(SP1), the system reverts the database state to exactly how it was when SP1 was created. A critical side effect of this operation is that any savepoints created after the target savepoint are immediately destroyed and invalidated. Because SP3 was created after SP1,12 rolling back to SP1 clear13s SP3 from the transaction's memory. Therefore, any subsequent attempt to call Database.rollback(SP3) will result in a runtime error because SP3 no longer exists.

To fix this logic, once the code rolls back to SP1 and addresses the condition, it would need to proceed forward through the logic again and potentially set new savepoints if needed. You cannot "jump back forward" to a later savepoint once an earlier one has been invoked, as the rollback has effectively erased the timeline that led to the later savepoints. Understanding this linear invalidation is essential for managing complex nested transactions in Apex.

==========

58

This requirement addresses two distinct needs: a user interface for59 data collection and a technical solution for long-running HTTP callouts.

First, a Lightning Web Component (Option B) or a Screen Flow (Option C) could both be used to collect inputs. However, in the context of advanced development and the specific use of "Continuation," a Lightning Web Component is the standard modern pairing. It allows for a rich, interactive UI to gather the "key inputs" from the user.

Second, for the long-running callout, the developer should use an Apex method that returns a Continuation object (Option D). Standard synchronous callouts in Salesforce have a timeout limit (typically 10 seconds, max 120) and, more importantly, they "hold" a thread in the Salesforce application server. If many users perform long callouts simultaneously, the org can hit the "Concurrent Request" limit, blocking other users. The Continuation class allows the request to be handed off to a specialized Salesforce service that waits for the response asynchronously. Once the external service responds, the Continuation service "wakes up" the Apex callback method. This pattern is essential for long-running integrations as it doesn't count against concurrent request limits while the external system is processing, providing a much more scalable user experience.

==========

###

Com31prehensive and Detailed 150 32to 250 words of Explanation:333435

In a Private sharing model36, record access is restricted to the own37er and users38 above them in the role hierarchy. To grant access to a user identified in a specific field (like a lookup), you need a dynamic sharing mechanism. Apex Managed Sharing (Option A) is the correct choice here because it allows a developer to programmatically create share records based on the value of the lookup field. When the Interviewer lookup is populated, a trigger can insert a record into the Candidate__Share object, granting the specified user 'Read' access.

Sharing rules (Option C) are generally too rigid for this scenario because they typically share records based on a static criteria or ownership, rather than a dynamic lookup to a User. Permission sets (Option B) grant object-level and field-level permissions but do not grant access to specific records that a user does not own in a Private OWD environment. Using Apex provides the necessary automation to ensure that as the interviewer changes, the sharing access is updated in real-time, maintaining a secure but functional interview process.

==========

When managing trigger logic that needs to be conditionally bypassed (often called a "Trigger Kill Switch"), using Hierarchy Custom Settings (Option D) is the best practice for scalability and maintainability.

A developer can create a Hierarchy Custom Setting named Trigger_Settings__c with a checkbox field Disable_Opportunity_Trigger__c. In the Apex trigger, the code should first check this setting:

if (Trigger_Settings__c.getInstance().Disable_Opportunity_Trigger__c) return;

Because it is a hierarchy setting, an administrator can enable this checkbox specifically for the User or Profile performing the data load without affecting the daily operations of other sales reps. Once the data load is complete, the setting can be toggled off. This approach is "extendable" because it doesn't require hardcoding IDs (Option A), which change between environments (Sandbox vs. Production).

Option C (List Custom Settings) is less flexible because it doesn't support the Profile-to-User hierarchy. Option B (Validation Rules) would stop the record creation but would result in a DML error in the trigger, potentially failing the entire data load transaction rather than simply skipping the logic. Hierarchy Custom Settings provide a clean, metadata-driven way to control execution flow across different user contexts.

12

The issue described is rooted in the Salesforce Order of Execution. When a record is saved, Salesforce follows a very specific sequence of events. First, original triggers (before and after) are executed. Only after these triggers have completed does the system evaluate and execute workflow rules.34

In this scenario, th5e following happens:6

The user saves the Opportunity with the count set to 4.7

The After Trigger fires. At this point, the field value i8s still 4. Since the trigger logic only creates a child record when the value "changes from 4 to 5," and it is currently exactly 4 (not yet 5), the condition is not met.

Next, the Workflow Rule fires and performs a field update, changing the count from 4 to 5.

According to the platform rules, a workflow field update causes Before and After Triggers to fire one more time to account for the change. However, in this second execution of the after trigger, Trigger.old now contains the value 4 (from the start of the second execution) and Trigger.new contains 5. While the condition old == 4 and new == 5 is now technically true, many developers fail to realize that the first execution (before the workflow) already bypassed the logic because the workflow hadn't updated the value yet.

If the trigger was written to look for the exact transition, it might fail during the first pass (where the value is 4) and potentially execute during the second pass. However, if the logic is not specifically handled to account for the re-entrant nature of workflow field updates, or if the "After triggers fire before workflow rules" (Option A) is the primary constraint being tested, it explains why the initial save logic didn't see the "5" until it was too late in the initial trigger context.

Comprehensive and Detailed 150 to 250 words of Explanation:

To 41ensure "all-or-nothing" behavior across multiple, distinct DML operations (such as an insert followed by a delete), a developer must manage the transaction boundary manually. In Apex, while a single insert statement is atomic, multiple statements are not automatically linked; if the second statement fails, the first statement's changes would typically remain committed to the database.

The correct implementation is to use Savepoints (Option B). By calling Database.setSavepoint(), the developer marks a specific state of the database. All subsequent DML operations are wrapped in a try-catch block. If an exception occurs during any of the operations, the code enters the catch block, where Database.rollback(sp) is called. This command reverts the database to the exact state it was in when the savepoint was created, effectively undoing any successful DML that occurred before the error.

Option A (SaveResults) allows for partial success, which contradicts the requirement to "prevent all execution." Option C (manual cleanup) is error-prone and cannot reliably revert system-generated fields or complex triggers. Option D (addError) is used in triggers to block a transaction but does not provide the programmatic rollback control needed for general Apex logic involving multiple lists.