Plat-Dev-301 Salesforce Certified Platform Developer II Exam Topics and Questions
These Salesforce Certified Platform Developer II (Plat-Dev-301) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise Plat-Dev-301 sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the Salesforce Certified Platform Developer II certification exam.
Let's Practice Free Salesforce Plat-Dev-301 Questions Aligned with Official Exam Topics
Advanced Developer Fundamentals sets the baseline for everything that follows. The three sub-topics here are narrower than the name suggests: they cover the parts of the platform that quietly break code when developers forget them. Localization and sharing models are easy to overlook during development and painful to fix in production. Getting these right early means the rest of your solution stands on solid ground. How Advanced Developer Fundamentals is tested At 15%, this domain shows up consistently enough to...
Advanced Developer Fundamentals sets the baseline for everything that follows. The three sub-topics here are narrower than the name suggests: they cover the parts of the platform that quietly break code when developers forget them. Localization and sharing models are easy to overlook during development and painful to fix in production. Getting these right early means the rest of your solution stands on solid ground.
How Advanced Developer Fundamentals is tested
At 15%, this domain shows up consistently enough to matter. Items are scenario-based: you will read a description of an org configuration or a business requirement and choose the implementation approach that fits it. The localization and multi-currency sub-topic catches candidates who know the feature names but have not thought through how they affect Apex execution, such as how currency conversion and locale-aware formatting interact with code that processes numeric or date fields.
The sharing sub-topic is where many candidates lose marks. Items here reward knowing precisely when Apex managed sharing is the right call versus when a sharing object or a with sharing declaration handles it. Picking the wrong mechanism fails the scenario even if the code itself would compile.
The metadata and settings sub-topic rewards distinguishing custom metadata types from custom settings in terms of deployability, cacheability, and subscriber visibility. Candidates who treat them as interchangeable consistently pick weaker options. Read each scenario for the deployment or packaging constraint before choosing.
The ITExamsTopics practice test for Platform Developer II lets you filter questions by topic, so you can target Advanced Developer Fundamentals specifically and see whether your misses cluster around sharing, localization, or metadata. Spotting that pattern early is faster than re-reading documentation. A free demo is available before you buy.
The question below tests one of the three areas covered here. Work through it before checking how you did.
The Salesforce admin at Cloud Kicks created a custom object called Region__c to store all postal zip codes in the United States and the Cloud Kicks sales region the zip code belongs to.
Object Name: Region__c
Fields: Zip_Code__c (Text), Region_Name__c (Text)
Cloud Kicks wants a trigger on the Lead to populate the Region based on the Lead's zip code. Which code segment is the most efficient way to fulfill this request?1234
At 27%, this is the largest single domain on the exam, and it earns that weight. Where the first domain asked you to get fundamentals right, this one asks you to make architectural calls under pressure: which automation tool, which Apex pattern, which async mechanism, which integration approach. The breadth is the trap. Candidates who know each area in isolation still lose marks when a scenario mixes two or three of them together. β Automation choices and trigger discipline The...
At 27%, this is the largest single domain on the exam, and it earns that weight. Where the first domain asked you to get fundamentals right, this one asks you to make architectural calls under pressure: which automation tool, which Apex pattern, which async mechanism, which integration approach. The breadth is the trap. Candidates who know each area in isolation still lose marks when a scenario mixes two or three of them together.
β Automation choices and trigger discipline
The exam distinguishes between declarative and programmatic automation not as a taxonomy exercise but as a decision problem. You need to know which tool to reach for given the specific constraints in the scenario: record volume, cross-object complexity, order of execution, and whether the process runs synchronously or asynchronously. Interactions between multiple automated processes are a recurring trap: a Flow and a trigger touching the same record in the same transaction can produce results that neither alone would cause, and the exam tests whether you can predict and prevent that.
Trigger best practices are examined at the level of pattern, not syntax. One trigger per object, handler class separation, and the consequences of violating those patterns in a multi-developer org are all fair game. The error handling and transactional integrity sub-topic connects directly here: knowing when a partial save is acceptable versus when you need a full rollback, and how savepoints and Database methods give you that control, changes which option you pick.
β SOQL depth and dynamic Apex
Advanced SOQL keywords such as FOR UPDATE, FOR VIEW, and OFFSET appear in this domain because they change query behaviour in ways that affect application correctness, not just performance. The exam tests whether you choose the right keyword for the scenario, not whether you can define it.
Dynamic Apex covers Schema methods, dynamic SOQL, and dynamic DML. The decision point is always about the scenario constraint: when field or object names are not known at compile time, or when you need to inspect field-level security programmatically, dynamic Apex is the answer. Items reward picking the specific method or approach that matches the requirement rather than the most powerful one available. Candidates who default to the broadest dynamic approach when a simpler static one would satisfy the requirement lose marks here.
β Asynchronous Apex and platform events
Asynchronous Apex covers Queueable, Batch, Scheduled, and Future methods. The exam tests the boundaries between them: governor limit relief, chaining, state maintenance, and callout eligibility. A scenario will give you a requirement, and the item rewards the async mechanism whose characteristics match that requirement exactly. Knowing that Queueable supports chaining and object state while Future does not is the kind of distinction that separates options.
Platform events bring a publish/subscribe model that sits outside the normal transaction boundary. Items here reward understanding what that means in practice: an event fired in a failed transaction still gets published, and a subscriber trigger runs in its own context. Candidates who treat platform events as just another trigger mechanism consistently pick options that mishandle failure scenarios.
β Integration patterns
Inbound and outbound integration covers REST and SOAP callouts, named credentials, and the patterns that keep integrations reliable under Salesforce's governor model. The exam tests the mechanics: callouts cannot be made after DML in the same transaction without using async, and the item rewards the solution that respects that boundary.
Candidates lose marks here by choosing integration approaches that work in isolation but fail under the transaction rules. Named credentials versus hardcoded endpoints is another tested distinction, and the scenario will usually include a security or multi-org deployment constraint that makes the choice clear if you read it carefully. The integration sub-topic rewards reading the full scenario before choosing, because the constraint that rules out three options is often in the last sentence.
How Process Automation, Logic, and Integration is tested
The weight here means you will see more items from this domain than any other. Expect scenarios that layer two or more sub-topics: a trigger best practice question may also hinge on async eligibility, or an integration question may depend on how you handle a DML-callout ordering constraint.
Items reward precision. Knowing that a particular async type is appropriate is not enough if you cannot also identify the governor limit implication or the failure mode the scenario is probing. The declarative-versus-programmatic sub-topic is particularly prone to distractor options that are technically valid but wrong for the stated constraint.
The biggest source of lost marks is treating this domain as a collection of separate topics and missing the cross-topic interactions. A candidate who knows triggers, knows Flow, but has never thought about what happens when both fire on the same record in the same transaction will pick the wrong option in a combined scenario. Platform events and transactional integrity items also reward knowing what happens in failure paths, not just the happy path.
Working through a full question bank under timed conditions is the most direct way to stress-test this domain. The ITExamsTopics practice test covers Process Automation, Logic, and Integration across the full range of sub-topics, and the timed mode shows you where your pacing breaks down before exam day. PDF and practice test formats are included on one purchase.
The question below draws on one of the sub-topics in this domain. Try it cold before reading on.
An org has a requirement that addresses on Contacts and Accounts should be normalized to a company standard by Apex code any time that they are saved. What is the optimal way to implement this?
After the back-end depth of Process Automation, this domain shifts to the client side, but the exam does not let you stay in one framework. You need to move fluently between Lightning web components, Aura components, and Visualforce, and the items test your ability to choose between them and to identify what needs to change in an Apex class when the front end demands it. Framework preference is irrelevant; scenario fit is everything. β Apex and UI framework interaction The...
After the back-end depth of Process Automation, this domain shifts to the client side, but the exam does not let you stay in one framework. You need to move fluently between Lightning web components, Aura components, and Visualforce, and the items test your ability to choose between them and to identify what needs to change in an Apex class when the front end demands it. Framework preference is irrelevant; scenario fit is everything.
β Apex and UI framework interaction
The first sub-topic is one of the most precisely worded in the exam: given a component and its Apex controller, identify what the Apex class needs to change. That framing matters. The item is not asking you to redesign the component; it is asking you to read existing code, spot the mismatch between what the component expects and what the controller provides, and name the fix. Common failure points include incorrect method visibility, missing @AuraEnabled annotations with the wrong cacheable setting, and return types that do not match what the component wire service or imperative call can handle.
Error display in the UI is tested as a best practice decision. The exam rewards surfacing errors at the right layer: catching exceptions in Apex and returning them in a form the component can present to the user, rather than letting unhandled exceptions produce generic platform error messages. Candidates who handle errors only on the Apex side or only in JavaScript consistently pick weaker options.
β Visualforce techniques
Visualforce appears in this domain because the exam expects a Platform Developer II to maintain and extend existing Visualforce pages, not just build new Lightning components. The sub-topic covers action methods for triggering server-side logic, partial page refreshes using actionRegion and actionSupport, and asynchronous operations via actionFunction. These are the tools that keep Visualforce pages responsive without a full postback.
Static resources appear across all three UI technologies. In Visualforce, a static resource is how you include external JavaScript or CSS reliably. In LWC and Aura, it serves the same purpose but the import mechanism differs. The exam tests whether you know the correct import syntax and lifecycle timing for each framework, not just the concept of a static resource. Picking the right mechanism for the right framework is the distinction that separates options.
β Component selection and responsive design
The framework selection sub-topic rewards knowing the trade-offs in concrete terms: LWC is the current standard and has better performance characteristics, Aura is required when you need certain legacy container components, and Visualforce fits specific scenarios involving PDF rendering or pages that must run outside the Salesforce UI. The exam will give you a requirement, and the item rewards matching the requirement to the framework whose capabilities satisfy it, not the most modern option.
Responsive design in LWC and Aura is tested through the specific platform mechanisms: flexipageRegionWidth, form factor detection via @salesforce/client/formFactor, and SLDS grid classes. The exam does not test generic CSS responsiveness; it tests how the Salesforce component model exposes device context to component markup. Candidates who apply general web development responsive patterns without using the platform-specific approach pick options that work in a browser but fail the scenario.
β Component communication
Event communication in LWC and Aura is a high-precision sub-topic. In LWC, the choice between a custom event dispatched up the DOM tree and a Lightning message service channel depends on whether the communicating components share a DOM ancestor. In Aura, application events versus component events follow a similar boundary. The exam rewards picking the mechanism that matches the component relationship described in the scenario.
Candidates lose marks here by applying the most powerful communication mechanism by default. Using a message channel when a simple parent-child event would suffice is not wrong in production, but the exam item rewards the most appropriate option for the stated relationship. Reading the component hierarchy in the scenario before choosing saves marks.
How User Interface is tested
At 20%, this domain is tied for second. Items frequently include code snippets: a component file, a controller class, or both. The read-and-identify format means you cannot answer from memory alone; you need to trace what the code does and spot the gap.
The most common source of lost marks is framework confusion. Aura and LWC share concepts but differ in syntax, lifecycle hooks, and communication patterns. An item that shows an Aura component asking about an LWC feature, or vice versa, is testing whether you notice the mismatch. Candidates who blur the two frameworks together under a generic mental model of Lightning components consistently pick weaker options.
Visualforce items reward knowing the specific tag and attribute that achieves the described behaviour, not a general description of the page lifecycle. The static resources sub-topic is often a distractor check: the concept is simple, but the import syntax and the timing of when the resource is available differ enough between frameworks to make the wrong option look plausible.
The ITExamsTopics PDF gives you a printable set of User Interface questions you can work through away from a screen, which suits the code-reading format this domain uses. Both PDF and practice test are included with one purchase, and a free demo lets you see the question style before committing.
The question below presents a UI scenario from this domain. Read any code carefully before choosing.
This domain covers what happens after the code is written: proving it works, finding out why it does not, and moving it safely between environments. The four sub-topics span Apex testing patterns, front-end debugging, root cause analysis, and deployment tooling. What ties them together is that each one tests a discipline most developers learn under pressure in production rather than by design. The exam rewards the candidate who has internalized the method, not just the tool names. How Testing, Debugging,...
This domain covers what happens after the code is written: proving it works, finding out why it does not, and moving it safely between environments. The four sub-topics span Apex testing patterns, front-end debugging, root cause analysis, and deployment tooling. What ties them together is that each one tests a discipline most developers learn under pressure in production rather than by design. The exam rewards the candidate who has internalized the method, not just the tool names.
How Testing, Debugging, and Deployment is tested
At 20%, this domain carries the same weight as User Interface and demands the same precision. Items often present a broken scenario: a test class that fails intermittently, a deployment that errors, or a debug log that does not show what the developer expected. The item rewards diagnosing the cause correctly, not describing the tool used.
The advanced testing sub-topic rewards knowing when a mock or stub is required rather than optional. If a test class makes an HTTP callout or depends on a specific query result, the item rewards the pattern that isolates the unit under test. Candidates who know the concept but cannot identify which interface to implement or which test annotation to apply lose marks.
The deployment sub-topic tests source-driven development mechanics: scratch orgs, unlocked packages, and the role of a CI pipeline. Items reward knowing which mechanism fits the described org structure and release process. Candidates who conflate change sets with modern source-driven tooling consistently pick options that fit a metadata-API workflow but not the scenario described. The root cause analysis sub-topic rewards reading governor limit output and log checkpoints methodically rather than guessing.
Checking a weak area through practice questions is more efficient than re-reading testing documentation. The ITExamsTopics practice test lets you isolate Testing, Debugging, and Deployment questions and measure your accuracy before exam day. Both PDF and practice test formats are included on one purchase.
The question below puts you in a diagnostic scenario from this domain. Commit to an answer before moving on.
Performance closes the exam and draws on every domain before it. Query structure from Process Automation, async patterns from the same domain, and code organisation from Testing all reappear here, but the lens shifts to efficiency under load. The five sub-topics cover UI performance, query and logic choices for large data volumes, async callouts, code reuse, and inefficiency identification. What the exam actually tests is whether you can read a scenario and spot the decision that will hurt at scale....
Performance closes the exam and draws on every domain before it. Query structure from Process Automation, async patterns from the same domain, and code organisation from Testing all reappear here, but the lens shifts to efficiency under load. The five sub-topics cover UI performance, query and logic choices for large data volumes, async callouts, code reuse, and inefficiency identification. What the exam actually tests is whether you can read a scenario and spot the decision that will hurt at scale.
β UI performance and large data volumes
UI performance items focus on the mechanisms Salesforce provides to reduce page load time and server round-trips: server-side caching via @AuraEnabled(cacheable=true), lazy loading patterns, and keeping component rendering logic out of Apex where the platform can handle it. The exam tests the specific mechanism, not the general principle. Knowing that caching improves performance is not enough; knowing which annotation enables it and what restrictions it imposes on the method is what earns the mark.
Large data volume query optimisation tests SOQL selectivity, the use of custom indexes, skinny tables, and the conditions under which a query will trigger a full table scan. Items here reward identifying the query structure change that avoids the scan, not the infrastructure change. Candidates who reach for a skinny table when a selective WHERE clause would suffice pick a valid but disproportionate option.
β Async callouts, code reuse, and inefficiency resolution
The async callout sub-topic tests a specific scenario type: a long-running external service call that blocks a synchronous transaction. The item rewards the async pattern that offloads the callout correctly, handles the response in a separate context, and stays within governor limits. Candidates who pick a Future method when the scenario requires a response callback, or who miss the DML-before-callout constraint, lose marks here.
Code reuse is tested as a design decision: when to extract logic into a service class, a utility class, or an invocable method that both Apex and Flow can call. The exam rewards the reuse pattern that fits the described multi-consumer scenario, not the most abstract one.
The inefficiency identification sub-topic gives you code and asks you to find the problem. Common targets include SOQL inside loops, unnecessary object instantiation inside loops, and redundant DML calls. The item rewards naming the specific inefficiency and the fix, so practise reading code for these patterns rather than memorising a list.
How Performance is tested
At 18%, Performance is the second-largest domain after Process Automation. Items lean heavily on code reading and scenario analysis. You will see Apex snippets with a performance problem embedded in them, and the item rewards identifying the exact line or pattern responsible, not a general category of issue.
The large data volume sub-topic is where candidates who have only worked in small developer orgs struggle. The exam describes a data volume that changes which query behaviour applies, and the item rewards knowing the threshold or condition that triggers the problem. Candidates who answer based on small-org behaviour pick options that are correct in development but wrong at scale.
Async callout items reward knowing the execution model: what runs in which transaction, what state is available in the callback, and what governor limits apply in each context. The code reuse sub-topic is often the most straightforward in this domain, but candidates lose marks by choosing the most flexible pattern rather than the one that fits the specific consumer relationship described in the scenario. Read the constraint before choosing the pattern.
Volume matters for Performance preparation: seeing the same concept tested from multiple angles is how you learn to recognise the trap in a novel scenario. The ITExamsTopics practice test gives you that volume across all five Performance sub-topics, with a free demo available so you can assess the question style before purchasing.
The question below targets a specific performance decision from this domain. Identify the constraint in the scenario before choosing.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Plat-Dev-301 Exam Questions π