Updated for Summer '26
New to this track? Our Salesforce Certified Platform Developer exam prep is the required first step. See our certification path to understand where this certification fits. The Salesforce Certified Platform Developer II exam weights Logic and Process Automation most heavily (22%) — see the full breakdown, study tips, and practice questions below. See our full study guide for deep section coverage. Ready to book? Read our exam tips and study plan.
Join 2.1K+ passed this month • Updated for 2026 • No sign-up required
$200 exam • 70% passing score • Free practice
Updated for Summer '26
This page is reviewed every release to stay aligned with the current exam blueprint.
Exam Blueprint Aligned
Section weightages match the official Summer '26 exam guide
Questions Reviewed
Practice questions and explanations checked each release cycle
Works on Any Device
Full practice experience on phone, tablet, or desktop
Free, No Sign-Up
Start practicing immediately — no account or email required
Written & verified by Krishna Mohan
5× Salesforce Certified · 12+ years in data engineering & Salesforce · Updated for Summer '26
Who is the Platform Developer II exam for?
- Mid-senior developers: You write Apex daily and want to prove advanced design pattern and architecture skills.
- PD1 holders: You passed Developer I and want the next credential in the developer track.
- Tech leads: You review code, make architecture decisions, and need to demonstrate senior-level Salesforce development expertise.
Exam Fees & Registration
Exam Fee
$200
One-time registration fee
Retake Fee
$100
If you need to retake the exam
Comparing certs? View all Salesforce exam fees in one place →
Certification Validity
Your Salesforce Certified Platform Developer II certification is valid for 3 years from the date you pass the exam. You'll need to maintain your certification through continuing education or retake the exam.
How to Register
Register for the Salesforce Certified Platform Developer II (PD2) exam through the official Salesforce certification portal.
Register for ExamExam data verification: questions, duration, passing score, fees, and section coverage were checked against official source references on .
Official sources: Exam guide·Salesforce exam pricing·Independent prep resource; no braindumps or leaked exam questions.
Salesforce Platform Developer II (PD2): Free Practice Exam & Study Guide (Summer '26)
The Platform Developer II certification validates your advanced development skills including design patterns, testing strategies, and integration techniques.
Required Prerequisite
You must complete this certification before attempting this one.
Salesforce Certified Platform Developer II Exam Weightage by Section
Exam Topics
Exam Tips
- 1Architecture and Logic are heavily weighted—design patterns, trigger frameworks, async Apex.
- 2Know when to use Queueable, Batch, Future, and Scheduled Apex.
- 3Understand namespaced packages, unlocked packages, and dependency management.
- 4Be ready for “how would you design?” and “what is the best approach?” questions.
Prerequisites
- •Salesforce Certified Platform Developer
- •2+ years development experience
Focus Areas
- •Architecture and Design Patterns
- •Advanced Apex and LWC
- •Testing and Deployment
- •Integration
Study Strategy
Focus on design and best practices, not just syntax.
Review trigger frameworks, dependency injection, and package development.
Practice explaining trade-offs.
Exam Format and First-Attempt Readiness
The Salesforce Certified Platform Developer II exam has 60 questions in 120 min, passing score 70%. Most Salesforce exams test scenario-based decisions — focus on when to use each feature, not just terms.
- Study Logic and Process Automation and Architecture first — together they carry 40% of the exam.
- Do timed question sets. Build pacing and confidence.
- Review why wrong answers are wrong. It improves scenario reasoning.
- Book the exam once your mock scores are steady above 70%.
Is the Platform Developer II Exam Hard?
Is the Platform Developer II Exam Hard?
PD2 is widely considered one of the hardest Salesforce certifications. It combines a 60-question multiple-choice exam with a separate programming assignment, and the $400 price tag reflects its architect-tier difficulty.
- 60 multiple-choice questions in 120 minutes — the longest non-architect exam.
- 70% passing score — higher than PD1 and most consultant exams.
- Separate programming assignment — graded on code quality, test coverage, and bulkification, not just passing tests.
- Advanced Apex patterns — trigger frameworks, governor limit strategies, asynchronous processing, and enterprise integration patterns.
Pass Rate Guidance
Most successful candidates have 2+ years of daily Apex development. Score 80%+ on multiple-choice practice exams before attempting the programming assignment.
Platform Developer II Exam Format Explained
Platform Developer II Exam Format Explained
PD2 has a unique two-part format. You must pass both the multiple-choice exam and the programming assignment to earn the certification:
Total Questions
60 scored questions
Time Limit
120 min
Passing Score
70%
Question Type
Multiple-choice & multiple-select
How Many Questions Are Scenario-Based?
The multiple-choice section is roughly 40% scenario-based, but the programming assignment is 100% hands-on. You receive a set of requirements and must build a working solution with proper test coverage in a proctored environment.
Best Way to Pass on Your First Attempt
- Write bulkified code from day one: The programming assignment tests bulk data handling with 200+ records. SOQL inside loops is an automatic failure pattern.
- Master async Apex: Know when to use @future, Queueable, Batch, and Schedulable — and their respective governor limits.
- Study design patterns: Trigger handler patterns, selector/domain/service layer separation, and dependency injection appear in both the MC and programming sections.
- Practice test-driven development: Write tests before code. The assignment grades test coverage AND assertion quality.
Platform Developer II: Key Concepts for the Exam
Design Patterns for Enterprise Apex
The exam tests four core patterns. Singleton ensures one shared class instance per transaction — used for handler registries and settings caches. Factory creates objects dynamically based on runtime type. Strategy encapsulates interchangeable algorithms in separate classes — ideal for pricing or routing logic that varies by record type. Trigger Handler separates trigger logic from business logic, enabling testable, single-responsibility handler classes. Know which pattern a given code smell or requirement maps to.
Asynchronous Apex: Choosing the Right Context
@future — simplest async, no complex parameters, no chaining, no job IDs. Queueable — supports complex sObject parameters, job chaining (enqueue from finish), and returns AsyncApexJob ID. Batch Apex — processes up to 50 million records in chunks; implement Database.Stateful to retain instance variables across iterations; chain in finish() via Database.executeBatch(). Schedulable — time-based entry point; use to kick off Batch or Queueable. The exam presents a scenario and asks which context is appropriate.
Integration: Callouts, Named Credentials, and Platform Events
Callouts cannot be made from synchronous triggers — use @future(callout=true) or Queueable with Database.AllowsCallouts. Named Credentials store the endpoint URL and authentication credentials securely, referenced in Apex as callout:NamedCredName. Platform Events provide loosely coupled, fire-and-forget publish/subscribe messaging — publishers do not wait for subscribers. Change Data Capture streams record change events to external systems without polling. The exam tests when each mechanism is appropriate.
Testing Strategy: Setup, Mocking, and Coverage
@TestSetup creates test data once for all test methods in the class, preventing repeated DML and improving performance. Test.startTest() / Test.stopTest() resets governor limits for the code under test and forces async jobs to complete. Mock callouts using HttpCalloutMock (implement the interface) or StaticResourceCalloutMock (use a static resource JSON file). System.assert patterns: assertEquals(expected, actual), assertNotEquals, assertTrue — always provide a meaningful message. 75% code coverage is required for deployment.
Security in Apex: Sharing, FLS, and AuraEnabled
with sharing enforces the running user's sharing rules; without sharing bypasses them; inherited sharing inherits from caller context. Classes default to without sharing if unspecified — a PD2-level trap. FLS enforcement: use Schema.SObjectType.getDescribe().fields.getMap() to check field accessibility, or stripInaccessible() to filter query results. @AuraEnabled exposes methods to LWC and Aura components — always combine with FLS and sharing checks. CRUD checks require Schema.SObjectType.Account.isCreateable() style checks.
Choose by data volume and chaining needs: @future for simple fire-and-forget calls with primitive parameters, Queueable when you need chaining or complex object parameters, and Batch when processing more records than fit in one transaction.
How to Pass the Salesforce Platform Developer II Exam
The PD2 exam requires deep technical expertise — questions assume you can read and reason about code, not just identify syntax. Focus on complex governor limit scenarios, asynchronous patterns, integration architecture, and enterprise design principles.
Asynchronous Apex Mastery
Know all four async patterns: Queueable (chainable, stateful), Batch (large data sets), Scheduled (time-based), and Future (simple async). Understand governor limits in async contexts (higher SOQL/DML limits) and when each pattern is appropriate.
Integration Architecture Decisions
REST vs. SOAP vs. Platform Events vs. Change Data Capture — know the use cases for each. Understand outbound messaging, callout limits, Named Credentials, and how to handle integration errors gracefully.
Platform Events & Event-Driven Architecture
Know how Platform Events enable event-driven, decoupled architectures. Understand the difference between Platform Events and CDC, how to publish events from Apex and Flows, and how subscribers process events reliably.
LWC Advanced Patterns
Understand component communication patterns: parent-to-child via properties, child-to-parent via custom events, and sibling communication via a shared service. Know when to use @wire vs. imperative Apex calls.
Testing Architecture
PD2 emphasizes test design: mock callouts with Test.setMock, test data isolation (SeeAllData=false), testing async Apex with Test.startTest/stopTest, and achieving meaningful code coverage vs. superficial coverage.
Is the Salesforce Certified Platform Developer II (PD2) Exam Hard?
DifficultyChallenging; plan about 8-16 weeks of focused prep.
Book When ReadyScore 85%+ on three timed mocks before scheduling.
Use Practice, Not DumpsOriginal practice questions build skill without risking your credential.
Exam format: 60 questions, 120 min, 70% passing score.
Get the Full PD2 Question Bank
Most candidates book the exam after scoring 75%+ on full mocks.
If you’re planning to test this quarter, aim to complete full mocks at least 10–14 days before your exam date.
Want to ensure you pass on your first try? Contact us for more information on our full 60-question mock exams and a personalized study plan. You can also reach out to km.krishnamohan25@gmail.com.
Request Mock Exams & Study PlanSalesforce Certified Platform Developer II (PD2) Exam FAQs
- What is covered on the Salesforce Certified Platform Developer II (PD2) exam?
- The Salesforce Certified Platform Developer II (PD2) exam—formerly Salesforce Certified Platform Developer II— covers section-wise weightage as shown above. Use the exam topics and practice questions on this page to align your study with the official outline.
- What is the difference between Platform Developer I and Platform Developer II?
- Platform Developer I focuses on basic Apex, LWC, and testing. Platform Developer II covers advanced topics like design patterns, architecture, advanced Apex, async processing, and package development. You need PD1 first.
Next Certifications After Developer
After this certification, common next steps in the developer track: