The Salesforce Certified Platform Developer II (Plat-Dev-301) exam is designed for developers who have mastered core Salesforce development and are ready to tackle advanced customization, optimization, and integration challenges. This certification validates your ability to design and implement complex solutions using Apex, Lightning components, and platform features. This page provides a clear roadmap of the exam syllabus, question formats, and practical preparation strategies to help you succeed on your first attempt.
Use this topic map to guide your study for Salesforce Plat-Dev-301 (Salesforce Certified Platform Developer II) within the Platform Developer II path.
The Plat-Dev-301 exam uses multiple question types to assess both conceptual knowledge and practical problem-solving skills in real-world scenarios.
Questions progress in difficulty and require you to apply knowledge across multiple domains, simulating the decision-making you'll do in production development work.
Build a structured study plan that covers all five domains systematically and reinforces connections between topics. Allocate 4-6 weeks for thorough preparation, with daily study sessions focused on one or two topic areas per week.
Explore other Salesforce certifications: view all Salesforce exams.
Strengthen your preparation with up-to-date resources from validexamdumps.com. These materials align to Plat-Dev-301 and cover practical scenarios with clear explanations.
Visit the exam page to download the PDF, Online Practice Test or get Bundle Discount offer for both formats: Salesforce Certified Platform Developer II.
Advanced Developer Fundamentals and Testing, Debugging, and Deployment typically account for a significant portion of the exam. However, all five domains are tested, and performance optimization and integration scenarios appear frequently because they reflect real production challenges developers face daily.
In practice, these domains overlap constantly. For example, you might write advanced Apex logic (Advanced Developer Fundamentals), optimize it to meet governor limits (Performance), expose it through a Lightning component (User Interface), test it thoroughly (Testing, Debugging, and Deployment), and integrate it with an external system (Process Automation, Logic, and Integration). Understanding these connections helps you answer scenario-based questions more effectively.
Ideally, you should have 1-2 years of Salesforce development experience and have completed the Platform Developer I certification. Hands-on work with Apex, Lightning components, and production deployments is invaluable. If you lack experience in specific areas like Flow or batch processing, use Salesforce Trailhead modules and practice environments to build confidence.
Common pitfalls include misunderstanding governor limits and when to use asynchronous processing, choosing the wrong automation tool for a scenario, and underestimating the importance of test coverage and code quality. Candidates also sometimes rush through scenario-based questions without fully analyzing the business requirements. Take time to read each question carefully and eliminate obviously wrong answers first.
Focus on timed practice tests and review weak areas rather than learning new content. Take at least two full-length practice exams under exam conditions to build pacing and confidence. Spend the final 2-3 days reviewing explanations for questions you missed and refreshing key concepts like governor limits, test class patterns, and common deployment pitfalls. Avoid cramming new material the night before the exam.
Universal Containers wants to notify an external system, in the event that an unhandled exception occurs, by publishing a custom event using Apex. What is the appropriate publish/subscribe logic to meet this requirement?
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.
Universal Containers uses Salesforce to track orders in an Order__c object. The Order__c object has private organization-wide defaults. The Order__c object has a custom field, Quality_Controller__c, that is a Lookup to User and is used to indicate that the specified User is performing quality control on the Order__c. What should be used to automatically give read only access to the User set in the Quality_Controller__c field?
In Salesforce, when organization-wide defaults (OWD) are set to Private, users only have access to records they own or those shared with them through the role hierarchy or sharing rules. In this scenario, the requirement is to grant access dynamically based on a value in a lookup field (Quality_Controller__c). Criteria-based sharing rules (Option D) are generally used for field values that are static or belong to 1a predefined set, but they cannot dynamically target a specific user identified in a lookup field on the record itself.2
Apex managed sharing i3s the optimal solution for this requirement. It allows developers to programmatically create sharing records (shares) to grant access to specific users or groups. When a record is created or the Quality_Controller__c field is updated, an Apex trigger can insert a record into the Order__Share object. This share record would specify the UserOrGroupId as the ID from the lookup field and the AccessLevel as 'Read'. This approach is highly flexible and ensures that as the quality controller changes, the sharing access is updated accordingly. User managed sharing (Option A), often referred to as manual sharing, requires manual intervention by the record owner and cannot be fully 'automatic' in the context of complex business logic without Apex. Therefore, Apex managed sharing provides the necessary automation and precision for record-level security based on dynamic lookup values.
==========
Universal Containers uses a custom Lightning page to provide a mechanism to perform a step-by-step wizard search for Accounts. One of the steps in the wizard is to allow the user to input text into a text field, ERP_Number__c, that is then used in a query to find matching Accounts.
Java
erpNumber = erpNumber + '%';
List
A developer receives the exception 'SOQL query not selective enough'. Which step should be taken to resolve the issue?
The 'SOQL query not selective enough' error occurs when a query on an object with a large volume of records (typically over 200,000) does not use a filtered index to narrow down the result set effectively. In Sales1force,2 the query optimizer must be able to use an index to scan a small enough percentage of the total records to maintain performance. When a query filters on a non-indexed field, the system is forced to perform a full table scan, which triggers this exception to prevent performance degradation.
To resolve this, the developer must ensure that the field used in the WHERE clause is indexed. Marking a custom field as an 'External ID' or 'Unique' automatically creates a custom index on that field. By marking ERP_Number__c as an External ID, the platform generates a underlying database index, allowing the query optimizer to quickly locate matching records without scanning the entire table. While the LIKE operator with a trailing wildcard (e.g., 'Text%') can utilize an index, it will only be considered 'selective' if the filter narrow the results below the platform's selectivity thresholds (typically 10% of the first million records). Making the field an External ID is the standard programmatic solution to provide the necessary indexing for selectivity. Option A is incorrect because moving a non-selective query to an asynchronous process does not change the fact that it is non-selective; it will still fail.
==========
Universal Containers analyzes a Lightning web component and its Apex controller. Based on the code snippets, what change should be made to display the contacts' mailing addresses in the Lightning web component?
Apex controller class:
Java
public with sharing class AccountContactsController {
@AuraEnabled
public static List
return [SELECT Id, Name, Email, Phone FROM Contact WHERE AccountId = :accountId];
}
}
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.
A developer created an Opportunity trigger that updates the account rating when an associated opportunity is considered high value. Current criteria for an opportunity to be considered high value is an amount greater than or equal to $1,000,000. However, this criteria value can change over time. There is a new requirement to also display high value opportunities in a Lightning web component. Which two actions should the developer take to meet these business requirements, and also prevent the business logic that obtains the high value opportunities from being repeated in more than one place?2021
To build a maintainable and scalable solution, a developer must separate business logic from trigger execution and avoid hard-coding threshold values.
First, the $1,000,000 threshold should be stored in Custom Metadata (Option B). Custom Metadata is superior to hard-coding or even Custom Settings in this context because the records are deployable and can be queried efficiently without counting against standard SOQL limits. If the business decides to lower the 'high value' threshold to $500,000, an administrator can simply update the Custom Metadata record without requiring any code changes or redeployments.
Second, the logic to identify these opportunities should be moved to a Helper Class (Option D). This follows the 'Separation of Concerns' principle. Instead of writing the SOQL query and logic inside the trigger, the trigger calls a method in the helper class. Similarly, the Lightning Web Component's Apex controller can call the exact same method in the helper class. This ensures that the definition of a 'high value opportunity' is managed in one single place in the codebase. If the logic becomes more complex (e.g., adding Industry filters), the developer only needs to update the helper class once to satisfy both the trigger and the UI component. Option A leads to 'spaghetti code,' and Option C is impossible as triggers cannot be called directly from JavaScript or other Apex classes.
==========
