PDII Salesforce Certified Platform Developer II ( Plat-Dev-301 ) Questions and Answers

A frequent mistake in Apex unit testing is failing to recognize that SObject variables in memory do not automatically reflect changes made to the database by triggers, flows, or other logic. When the developer saves the Account record in the test4, the database is updated (e.g., a trigger or the controller changes the OwnerId to the Queue ID). However, the variable used in the test still holds the original data that was present when it was first instantiated or inserted.

To successfully assert the change, the developer must perform a "refresh" query. This involves using a SOQL statement to retrieve the record from the database using its ID: Account updatedAcc = [SELECT OwnerId FROM Account WHERE Id = :acc.Id];. The assertion should then be performed against updatedAcc.OwnerId.

Option B correctly identifies this as the root cause. Option A is irrelevant as Queueable is an asynchronous execution pattern. Option C (seeAllData=true) is a poor practice and is not required for testing logic that modifies records. Option D is unrelated to assertion logic. Standard test isolation requires that you explicitly re-query the database to verify side effects caused by platform automation or controller logic.

==========

When a trigger unexpectedly executes twice (recursion), it is typically due to the Salesforce Order of Execution. A common cause is a workflow rule, process, or flow updating the same record that initiated the transaction, which re-triggers the original Apex trigger. To identify exactly where this second execution is being initiated, the most effective technique is to use system.debug() statements in conjunction with the Developer Console logs (Option D).

By placing debug statements at the start of the trigger (e.g., System.debug('Trigger Fired');), the developer can examine the execution log to see how many times that line appears. More importantly, the execution log provides a hierarchical "trace" of the entire transaction. The developer can look for entries like FLOW_CREATE_INTERVIEW or WF_RULE_EVAL_BEGIN between the two trigger execution blocks. This trace reveals exactly which automation (Flow, Workflow, or another Trigger) caused the record to be updated a second time.

Option A is inefficient and disruptive to production environments. Option B is too broad and doesn't provide the internal execution context. Option C checks for code validity but does not diagnose runtime logic issues in a live environment. Tracing the execution through logs is the standard programmatic way to debug recursion and side effects in Salesforce.

5

The iss6ue described is a direct result of how Salesforce treats data during sandbox refreshes and unit testing. Custom Settings (both List and Hierarchy) store their information as data records. By default, sandbox refreshes do not include data records from Production unless it is a Full Sandbox. Furthermore, Apex unit tests are isolated from organization data; they cannot "see" Custom Setting records unless the records are explicitly created within the test or the @isTest(SeeAllData=true) annotation is used (which is a poor practice).

Custom Metadata (Option C) solves this by treating configuration records as metadata rather than data. Because they are metadata, the records are automatically included in every sandbox refresh and are deployable via Change Sets or the Salesforce CLI. Most importantly, Custom Metadata is visible to Apex unit tests without needing to create setup data or bypass test isolation. This ensures that configuration-dependent logic remains consistent across all environments and that tests pass reliably after a refresh. Replacing Custom Settings with Custom Metadata is the modern Salesforce standard for environment-independent configuration management.

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 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.

When you need to retrieve the total count of records in a large dataset (millions of records), a SOQL aggregate query using COUNT() (Option A) is the most efficient and performant method. Salesforce optimizes aggregate functions at the database 13level. Unlike a standard query that returns in14dividual records and counts against the "50,000 SOQL rows" limit, a COUNT() query returns a single integ15er result and counts as only one row to16ward the governor limits.17

This allows a developer to count millions of records in a single synchronous transactio18n without hitting row limits or causing significant CPU time issues. Option D (SOQL for loop) is the worst approach, as it would attempt to load every individual record into memory, hitting the 50,000-row limit almost immediately and likely causing a LimitException or Request Timeout.

Option B (Batch Apex) is unnecessary for a simple count and is much slower because it runs asynchronously. Option C (SUM) is used for adding up values in numeric fields, not for counting the number of records. For high-volume record counting, SELECT COUNT(Id) FROM Opportunity is the platform-standard approach to provide data to a Lightning component efficiently.

The lightning-layout and lightning-layout-item components utilize a 12-column grid system to create responsive layouts. In this system, "12" represents the full width of the container (one column), while "6" represents half the width (two columns side-by-side). To manage responsiveness across different screen sizes, Salesforce provides specific attributes that target different breakpoints.

The size attribute defines the default width for the smallest devices (mobile). By setting size="12", the item takes up the full width of the screen on mobile devices, resulting in a single-column stack. The medium-device-size attribute targets tablets and small desktop screens. By setting medium-device-size="6", the layout item is instructed to occupy only half of the grid (6 out of 12 columns) once the screen reaches the "medium" breakpoint. When two adjacent items both have this setting, they will sit side-by-side, creating a two-column layout.

Option C is the correct answer because medium-device-size is the standard attribute used to transition from a mobile view to a tablet/desktop view in the Lightning Design System (SLDS) grid logic. Using size="12" ensures the "one column" requirement for mobile, and medium-device-size="6" satisfies the "two columns" requirement for larger screens.

==========

16

The optimal architectural ap17proach for complex logic on a single object is to use a single trigger per object that delegates responsibilities to a helper class. This requirement involves two distinct types of logic: field manipulation (uppercase names) and cross-record updates (ensuring only one primary contact).

In Salesforce, Before triggers are ideal for updating fields on the record that initiated the trigger, as the changes are saved to the database without an additional DML statement. Therefore, converting the LastName to uppercase should occur in a before update and before insert context. Conversely, the "Is Primary" logic requires updating other records (de-selecting other contacts on the same account). This must happen in an After trigger context to ensure the primary record has been successfully updated and to avoid recursion or conflicts with the initial save.

Option D is the best practice because it follows the "One Trigger Per Object" design pattern. By using a single trigger with multiple context variables (isBefore, isAfter, isUpdate), the developer can cleanly route the "Last Name" logic to a before-save helper and the "Is Primary" cross-record update logic to an after-save helper. This centralized control prevents multiple triggers from firing in an unpredictable order and simplifies maintenance and debugging.

==========

Every Apex test execution is treated as a temporary transaction. One of the most critical aspects of this execution is that any changes made to the database—including the insertion, modification, or deletion of records—are automatically rolled back at the end of the test run. This mechanism ensures that unit tests do not leave behind "garbage" data or alter the state of the organization's actual business data, maintaining a consistent environment for development and production.1234

In this specific scenario, the @isTest(SeeAllData=true) annotation is used, which allows the test method to view existing data in the organization. Bec5ause the org already contains five accounts starting with "Test," the test method sees them. When the test code inserts a new 6account named "Test1," the count within that specific transaction becomes six. The subsequent code queries for these six accounts an7d del8etes them. While the test is running, the deletion is successful, which is why the assertion checking for zero accounts passes.

However, once the test finishes, the entire transaction is rolled back. The rollback effectively "undoes" the deletion of the original five accounts and the creation of the one new account. Consequently, the organization returns to its exact state from before the test was initiated. The five original accounts remain in the database as if the test never occurred, making option A the correct answer.

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.

Source-driven development shifts the "source of truth" from the Salesforce org to a version control system (like Git). Salesforce DX (Developer Experience) was specifically designed to support this paradigm by introducing the Salesforce CLI (Command Line Interface). The Salesforce CLI is the primary engine for modern CI/CD pipelines because it allows for the scripted creation of scratch orgs, automated testing, and the deployment of source code to any environment (sandboxes, scratch orgs, or production) using simple command-line instructions3.

Unlike traditional tools, the Salesforce CLI supports the "Source" format, which is more granular and easier to manage in version control than the traditional Metadata format used by the Ant Migration Tool. Change Sets (Option B) are manual, UI-driven tools that cannot be automated in a CI/CD pipeline and are strictly org-to-org. Salesforce Extensions for VS Code (Option C) provide a powerful IDE interface for developers, but the extensions themselves rely on the underlying Salesforce CLI to perform deployments; they are not the automation tool used by the pipeline itself. The Ant Migration Tool (Option D) is an older technology that uses the Metadata API and is generally considered legacy compared to the more flexible and powerful Salesforce DX commands. Therefore, Salesforce CLI with Salesforce DX is the optimal choice for a robust, automated source-driven deployment strategy.

==========

For an Apex method to be reachable by a Lightning Web Component, it must be annotated with @AuraEnabled. In this code, line 03 is the entry point for the search functionality. Without the @AuraEnabled annotation on line 03 (Option D), the JavaScript controller will not be able to "see" or invoke the search method, resulting in a runtime error.

Furthermore, because this method returns a custom "Wrapper" class, the platform's serialization engine needs to know which specific properties within that wrapper class should be sent to the client-side JavaScript. By default, the LWC framework does not serialize class members unless they are explicitly marked. Therefore, the developer must add @AuraEnabled to lines 10 and 11 (Option C). Without this, even if the method executes successfully, the account and matchProbability properties will be stripped during the JSON conversion, and the component will receive a list of empty objects.

Adding @AuraEnabled to the class definitions themselves (Lines 01 or 09) is not required; the annotation is only necessary on the specific methods and member variables that participate in the data exchange between Apex and JavaScript. This explicit marking ensures security and efficiency by only exposing the data intended for the user interface.

Jest is a powerful JavaScript testing framework used for Lightning Web Components (LWC) to ensure individual units of code function correctly in isolation. One of the primary reasons to use Jest is to verify the DOM output of a component (D). Since LWC is a UI framework, Jest allows developers to inspect the rendered HTML to ensure that elements, classes, and data are displayed as intended after a state change. Furthermore, Jest is essential for testing basic user interaction (A). Developers can simulate events like button clicks or text input and then assert that the component’s state or UI updates accordingly.

Another critical use case is to verify that events fire when expected (E). Components often communicate with parents via custom events; Jest allows you to "spy" on these events to ensure they are dispatched with the correct detail payload at the right time. Conversely, Jest is not intended for testing how multiple components work together (C)—this is the domain of integration tests or end-to-end tests (like UTAM). Additionally, Jest tests should focus on the component's public API and observable behavior; testing non-public (private) properties (B) is generally discouraged as it leads to brittle tests that break upon internal refactoring. By focusing on DOM output, interactions, and events, Jest provides a fast, reliable way to maintain component quality.

==========

48

Platform Events provide a powerful way to integrate Salesforce with external systems using an event-driven architecture. To meet the requirement of notifying an external system abo49ut an exception, the developer must first define a Custom Platform Event (e.g., Error_Event__e). In the Apex code, specifically within a catch block, the developer should instantiate this event and publish it using the EventBus.publish() method (Option A).

Once published, the event is placed on the event bus. External systems can listen for these events by subscribing to the event channel. The standard protocol for external clients to subscribe to Salesforce Platform Events is CometD, an implementation of the Bayeux protocol that allows for long-polling and real-time push notifications.

Option B and C are incorrect because addError() is a method used in triggers or Visualforce to display a validation error message to the UI and roll back the transaction; it is not used for publishing Platform Events. Option D is incorrect because an external system cannot receive an event unless the Salesforce application explicitly publishes it to the bus. Using EventBus.publish() with a CometD subscriber provides a robust, decoupled integration pattern for real-time error reporting.

Comprehensive and Detailed 150 to 25042 words o43f Explanation:

In Lightning Web Components, external JavaScript libraries or CSS files stored in Static Resources must be imported using a specific syntax. The correct way to reference the resource URL is through the @salesforce/resourceUrl scoped module. Option A correctly follows this convention: import resourceName from '@salesforce/resourceUrl/staticResourceName'. This statement provides the component with the URL string pointing to the resource.

It is important to note that the import statement only gives you the URL of the file. To actually load and execute the JavaScript within the component, you would then need to use the loadScript function from the lightning/platformResourceLoader module, typically within the renderedCallback() lifecycle hook.

Option B is incorrect because resource imports are default imports, not named imports. Option C uses Aura framework syntax ($A.get), which is not supported in LWC. Option D uses a syntax that resembles Aura's ltng:require tag, which does not exist in the LWC template syntax. Therefore, Option A is the essential first step for any LWC to identify and eventually load a static resource.

==========

22

In Apex, "bulkification" is the practice of ensuring code can handle multiple records efficiently without hitting governor limits. Snippet A demonstrates the correct bulkified approach for this requirement. It first iterates through the opportunityList to collect all unique AccountId values into a Set. Then, it performs a single SOQL query to retrieve all relevant Accounts and their child Contacts using a subquery (Inner Join). This ensures that the code only consumes one SOQL query regardless of how many opportunities are in the input list.

Snippet B is syntactically incorrect and will fail to compile. In Apex, you cannot use dot-notation (like opportunityList.AccountId) on a List collection to retrieve a set of IDs from its elements. To access the AccountId of records within a list, you must iterate through the list or use a map. Even if corrected to use a proper ID collection, Snippet A is often preferred when you need the relationship context between the Account and its Contacts. Most importantly, Snippet A correctly identifies the need to extract IDs into a separate collection before querying, which is a fundamental requirement for writing scalable Apex. It avoids the "Query in a loop" anti-pattern and adheres to the platform's execution model.

==========

When the structure of a query—such as the number of filters or the specific fields in the WHERE clause—is not known at compile-time and must be determined at runtime based on user input, "Dynamic SOQL" is the required feature. Unlike static SOQL, which is written directly in the Apex code and validated during compilation, Dynamic SOQL allows a developer to construct a query as a string.14

In this scenario, the user might choose to filter by 'Industry' and 'AnnualRevenue' in one session, but only by 'BillingCity' in another. By using Database.query(queryString), the developer can programmatically append WHERE clauses to the base query string based on the selections made in the Lightning Web component. This provides the flexibility to handle the varying number of fields (up to five) without writing dozens of different static queries or complex "if-else" blocks that are difficult to maintain.

While describeSObjects() (Option A) can be used to get metadata about the fields, it doesn't execute the query. SOSL (Option C) is for text-based searching across multiple objects and is less efficient for specific field filtering on a single object. The REST API (Option B) is an external interface and not a feature of Apex used to solve internal filtering logic within an LWC controller. Therefore, Dynamic SOQL is the standard tool for building highly flexible, user-driven search interfaces on the platform.

==========

To display new data in a lightning-datatable, changes are required at both the Data Retrieval (Apex) layer and the UI Definition (JavaScript) layer.

First, the SOQL query in the Apex controller must be updated to include the address fields. While MailingAddress is a compound field in Salesforce, in a SOQL query intended for a datatable, it is often best to retrieve the individual components (e.g., MailingStreet, MailingCity, MailingState).

Second, the JavaScript controller for the LWC must be updated. The columns array in the JS file defines which data properties the lightning-datatable looks for. Even if the Apex method returns the address data, the datatable will not render it unless there is a corresponding column definition with the correct fieldName property.

Option D correctly identifies this two-step process. Option B is incomplete because the UI wouldn't know to show the new data. Option C is incorrect because you don't "extend" the component to add columns; you simply pass a configuration array. Option A is inefficient as it creates extra server round-trips for data that should be fetched in a single query. By aligning the SOQL fields with the datatable column definitions, the mailing address can be displayed seamlessly.

1516

In Salesforce Apex, each DML statement is its own mini-transaction unless specific measures are taken to group them. If a developer performs an insert parent; followed by an insert child;, and the child insertion fails due to a validation rule, the parent record remains in the database. This leads to "orphaned" parent records, violating the bu17siness requireme18nt that every parent must have a child.

To ensure "all-or-nothing" behavior across multiple DML statements, the developer should use Database.setSavepoint() and Database.rollback(). By setting a savepoint before the parent is inserted, the developer creates a "marker" for the database state. If the child insertion fails and throws an exception, the code enters the catch block. Within the catch block, the developer can call Database.rollback(sp), which reverts the database to the state before the parent was ever inserted. This ensures that either both records are created successfully or neither is created.

Option A is incorrect because allOrNone only applies to the records within a single Database.insert() call; it cannot link the success of two separate DML calls for different objects. Option B is a manual cleanup approach that is less reliable than a system-level rollback. Option D is typically used in triggers to prevent saving, but it doesn't provide the transactional control needed in a custom method with multiple DML steps. Using savepoints is the standard best practice for managing multi-object transaction atomicity.

Platform Events follow an event-driven architecture that allows for seamless integration between internal Salesforce processes and external applications. Once an event is defined, it must be "published" to the event bus to be seen by subscribers.

External Applications (Option C) publish platform events by using the Salesforce REST, SOAP, or Pub/Sub APIs. Essentially, an external app "inserts" a record into the event object (e.g., Order_Event__e). Since platform events are treated as a special type of Salesforce object, the standard API create call acts as the publishing mechanism.

Option A is incorrect because the Streaming API is used for subscribing to events, not for publishing them. Option B is incorrect because Outbound Messages are a legacy SOAP-based notification tool and do not publish platform events. Option D is incorrect because Entitlement Processes are service-level management tools and are not part of the event-driven architecture.

For internal apps, platform events can also be published via Apex (using EventBus.publish()) or declaratively using Flow Builder. The key takeaway for external integration is that publishing is handled via standard Salesforce APIs, making it accessible to any system capable of making an HTTP request.

Managing "Trigger Kill Switches" is a critical requirement for data migration. The most "extendable" and platform-standard approach is using a Hierarchy Custom Setting (Option C).

A hierarchy setting allows for different values at the Organization, Profile, and User levels. A developer can create a checkbox field called Disable_Opportunity_Trigger__c. In the trigger, the code would check: if (MySettings__c.getInstance().Disable_Opportunity_Trigger__c) return;. During a mass data load, the administrator can enable this checkbox specifically for the integration user or the specific administrator performing the load. Because it is a hierarchy, it doesn't affect standard users.

This approach is superior to hard-coding Profile IDs (Option A) because IDs change between environments. It is also better than List Custom Settings (Option D) because it provides the automatic "fallback" logic (User > Profile > Org) that makes management much simpler. Validation rules (Option B) would cause the trigger to fail with an exception, which could stop the entire data load transaction, whereas the Custom Setting approach allows the trigger to "gracefully" skip its logic and allow the Opportunity to be saved without creating a Contract.

In Lightning Web Components (LWC), data flows "down" via properties and "up" via events. When a child component needs to communicate a change in a property or state to its parent, it must dispatch a CustomEvent. To pass specific data—such as the new value of the passthrough property—along with the event, the developer must use the detail property within the event initialization object.

Option C is the correct syntax. It creates a new CustomEvent named 'passthrough' and assigns the current value of the component's property (this.passthrough) to the detail key. The parent component can then listen for this event (using onpassthrough={handleEvent}) and access the value via event.detail. Option A is incorrect because it wraps the variable in quotes, passing the literal string "this.passthrough" instead of the actual data. Option B creates an event but fails to include the data payload, meaning the parent would know an event occurred but wouldn't receive the new value. Option D uses incorrect syntax for event naming and variable referencing. Using the standard CustomEvent constructor with the detail property is the platform-standard way to ensure robust, typed data communication between component layers in the Shadow DOM.

==========

Visualforce provides two primary ways to perform AJAX-style operations: JavaScript Remoting and Remote Objects. The primary benefit of JavaScript Remoting (Option A) is its ability to execute complex server-side logic.

JavaScript Remoting works by calling an Apex method annotated with @RemoteAction. Because this is a standard Apex method, it can perform advanced calculations, complex SOQL queries with multi-object joins, DML operations across various objects, and even call out to external web services.

In contrast, Remote Objects are purely declarative. They allow you to perform basic CRUD operations (Create, Read, Update, Delete) on a single object directly from JavaScript without writing any Apex. While Remote Objects are easier to set up for simple data entry, they cannot handle "business logic" (like calculating a discount based on customer history) during the data retrieval process.

Option B and C describe Remote Objects, not Remoting. Option D is a feature of standard Visualforce tags like , but not a specific differentiator for Remoting. Therefore, when your application needs "brains" on the server, JavaScript Remoting is the superior choice.

Comprehensive and Detailed 43150 to 250 words of Explanation:44

The critical requirement in this scenario is that "no additional steps are needed45" upon deployment. This refers to the ability to migrate not just the logic, but also the configuration data (the rates) across environments (e.g., from Sandbox to Production).

Custom Metadata Types (Option A) are the only option among those listed that are treated as metadata rather than data. This means that individual records within a Custom Metadata Type can be included in Change Sets, unlocked packages, or via the Metadata API. When the developer deploys the code, they include the metadata records for the regions and rates in the same package. Once the deployment finishes, the code can immediately query those rates and perform calculations without any manual record creation in the production environment.

In contrast, Custom List Settings (Option B), Custom Objects (Option C), and Hierarchy Settings (Option D) store their records as "data." Data is not deployable via Change Sets. If a developer used these options, they would have to manually re-enter all the regional rates in Production after the code was deployed, which violates the requirement for a seamless, automated deployment process.

==========

The "optimal" Apex trigger logic is defined by its bulkification and strict adherence to Salesforce governor limits. In Apex, a trigger can process up to 200 records in a single batch. If a developer places a SOQL query inside a loop, the transaction will fail with a System.LimitException if more than 100 records are processed, as the limit is 100 synchronous SOQL queries.

Option A follows the industry-standard "Bulkify, Query, and Map" design pattern:

Collection: It iterates through the input records once to gather all relevant search criteria (Zip Codes) into a Set.

External Query: It performs a single SOQL query outside of any loop to fetch all matching Region__c records for the entire batch. This is the most critical step for scalability.

Mapping: It organizes the results into a Map (Zip Code to Region Name). Maps provide $O(1)$ constant-time lookup performance.

Final Assignment: It iterates through the Leads a second time and assigns the Region using the Map.

Options B, C, and D are all anti-patterns. Option C is the most dangerous, as it executes a query for every single record. Options B and D are slightly better but still redundant, as they execute a query inside a loop that retrieves data already retrieved in previous iterations. Only Option A ensures the code is efficient, bulk-safe, and stays well within governor limits even under heavy data loads.