Updated for Spring '26
PD1 Study Guide (Spring '26): Complete Platform Developer I Exam Prep
The Salesforce Platform Developer I (PD1) certification is the primary developer credential on the Salesforce platform. This study guide covers every exam section with the Apex patterns, testing rules, and LWC concepts you need to pass — not just the topic list.
Written and reviewed by Krishna Mohan — ADM-201, PD1, PD2, App Builder & Consultant certified. Updated for Spring '26. Methodology · Contact
Ready to sharpen your exam strategy? Prepare with our Platform Developer I Exam Tips & Strategy Guide — high-weight topics, scenario tactics, and mock-test targets for first-attempt success.
Honest Cert Breakdown
Difficulty: Hard
4/5Apex, SOQL, LWC, governor limits, test classes. Requires real coding experience — this is not a study-your-way-through exam. Hands-on org work is essential.
Salary Range
$98,000–$138,000 / year
US average for certified professionals • Updated Spring '26 • Source: Salesforce Talent Ecosystem
Is it worth it?
Essential for any Salesforce developer career. Consistently high demand and a clear salary ceiling above non-certified developers.
PD1 Exam at a Glance
60
Questions
110 min
Time Limit
68%
Passing Score
$200
Exam Fee
Retake fee: $100. No hard prerequisites required (ADM-201 knowledge assumed). 5 unscored pilot questions included — you cannot identify them.
PD1 Exam Sections and Weightage
Process Automation and Testing together account for 55% of the exam. Master Apex and test classes first.
Apex classes, triggers, governor limits, bulkification, async Apex (Future, Batch, Queueable, Scheduled)
Test classes, @isTest, Test.startTest/stopTest, code coverage (75% minimum), debugging tools, change sets, metadata API
Lightning Web Components (LWC), Aura components, Visualforce basics, @wire service, lightning-record-form, JavaScript in LWC
REST vs SOAP callouts, HttpRequest, HTTP methods (GET/POST/PUT/DELETE), JSON parsing, Named Credentials, external services
Platform basics, MVC pattern, declarative vs programmatic, object relationships, sharing model fundamentals
What Each Section Actually Tests
Process Automation and Logic (30%)
The heart of the PD1 exam. Governor limits are the single most tested concept: 100 SOQL queries, 150 DML statements, 50,000 rows returned per query. Bulkification is a specific governor limit scenario — you must know why SOQL or DML inside a for-loop violates limits and how to fix it using List/Map patterns. Async Apex: Future methods (simple callouts, @future(callout=true), cannot be monitored); Batch Apex (Database.Batchable interface, 3 methods: start/execute/finish, up to 50M records in batches of 200 default); Queueable (can be chained, accepts non-primitive types); Scheduled (Schedulable interface, cron expression). Most common mistake: confusing when to use Future vs Queueable — Queueable is preferred when you need chaining or non-primitive parameters.
Testing, Debugging, and Deployment (25%)
Test class rules the exam enforces: 75% code coverage minimum for deployment (not per-class, across the org), @isTest annotation on class and methods, Test.startTest() / Test.stopTest() resets governor limits and forces async execution, System.assert/assertEquals/assertNotEquals for assertions. Test data isolation: @isTest(SeeAllData=false) is the default — test classes cannot see real org data unless SeeAllData=true (avoid this). Use Test.getStandardPricebookId() for price book in tests. Deployment: sandbox → production via change sets or metadata API. SFDX/SF CLI: sfdx force:source:push (scratch org), force:source:retrieve, force:mdapi:deploy. Debugging: Developer Console, Debug Logs, SOQL Query Plan, anonymous Apex for testing.
User Interface (23%)
Lightning Web Components (LWC) dominate this section. Key concepts: @api (public property, passed from parent), @track (reactive private property — deprecated in newer versions, all properties reactive now), @wire (calls Apex or standard library functions declaratively). Component lifecycle hooks: constructor(), connectedCallback(), renderedCallback(), disconnectedCallback(). LWC to Apex: @AuraEnabled on Apex methods, cacheable=true for wire, without cacheable for imperative calls. LWC events: custom events bubble with composed+bubbles options. Aura: still tested at lower depth — know component lifecycle, Aura events vs LWC custom events, and that Aura can contain LWC but not vice versa.
Integration (15%)
REST vs SOAP: REST uses JSON, lightweight, stateless, simpler to implement; SOAP uses WSDL/XML, stricter contract, legacy systems. Callouts: HttpRequest object, HttpRequest.setEndpoint(), HttpRequest.setMethod('GET'), Http.send(). Named Credentials store endpoint + authentication — use them for credentials security. Callouts cannot be made from Apex triggers without @future(callout=true) or Queueable. Inbound: REST API (standard /services/data/vXX.0/ endpoints), SOAP API (WSDL import), Bulk API (CSV-based, high-volume). Know that callouts count against the 10 callouts per transaction limit.
Salesforce Fundamentals (7%)
MVC pattern (Model = objects/fields, View = Visualforce/LWC, Controller = Apex), declarative vs programmatic development, when to choose each. Object relationships (master-detail, lookup, many-to-many via junction object), sharing model basics (OWD, role hierarchy, sharing rules, with sharing / without sharing in Apex). Know that with sharing enforces the running user's sharing rules; without sharing ignores them (admin context).
Critical Apex Patterns for the Exam
Bulkified Trigger Pattern (always correct):
trigger AccountTrigger on Account (before insert, before update) {
List<Id> accountIds = new List<Id>();
for (Account acc : Trigger.new) {
accountIds.add(acc.Id); // collect IDs
}
// SOQL OUTSIDE the loop — queries all at once
Map<Id, Contact> contacts = new Map<Id, Contact>(
[SELECT Id, AccountId FROM Contact WHERE AccountId IN :accountIds]
);
}Async Apex Decision Tree:
- Need a callout from a trigger? → @future(callout=true)
- Need to chain jobs or pass non-primitive data? → Queueable
- Need to process millions of records? → Batch Apex (Database.Batchable)
- Need to run daily/weekly automatically? → Schedulable (implements Schedulable)
Trigger context variables (must memorise):
- Trigger.new — new record values (insert, update, undelete)
- Trigger.old — old record values (update, delete)
- Trigger.newMap / Trigger.oldMap — Maps of Id to record
- Trigger.isBefore / Trigger.isAfter — when in the execution order
6-Week PD1 Study Plan
Week 1 — Apex Fundamentals and Governor Limits (30%): Apex syntax, data types, SOQL, SOSL, DML operations, governor limits. Practice in Developer Edition org: write a simple trigger with SOQL outside the loop. Complete Trailhead “Apex Basics & Database” and “Apex Triggers” modules.
Week 2 — Async Apex (part of 30%): Future methods, Batch Apex, Queueable, Schedulable. Learn the interfaces and method signatures by writing each type. Practice: write a batch class that updates all Contacts missing an email. Run it in anonymous Apex. Verify with System.debug logs.
Week 3 — Testing and Deployment (25%): Test class structure, @isTest annotations, Test.startTest/stopTest, code coverage, mock callouts (HttpCalloutMock), and static resources for test data. Practice: write a test class for your batch Apex that achieves 100% coverage.
Week 4 — LWC and User Interface (23%): LWC component anatomy (HTML/JS/CSS/XML), @api, @wire, @track, component communication (events, pubsub), lightning-record-form, lightning-datatable. Practice: build a simple LWC that displays accounts using @wire(getRecord).
Week 5 — Integration and Fundamentals (22%): REST/SOAP callouts, HttpRequest, Named Credentials, inbound REST API, Bulk API overview. Review MVC, sharing model (with sharing / without sharing). Study integration patterns: outbound (Apex callouts) and inbound (custom REST endpoints with @RestResource).
Week 6: Full timed mock exams (60 Q / 110 min), weak-area targeted revision. Score 78%+ consistently (PD1 passing is 68% — aim 10 points above) before booking.
How to Approach PD1 Scenario Questions
- Governor limit questions: If you see SOQL or DML inside a for-loop in the code — that is wrong. The fix is always to collect IDs in a list, query outside the loop, and store results in a Map. Eliminate all answers that put SOQL/DML inside loops.
- Test class questions: If the scenario mentions “code coverage” below 75%, you need to add test methods. If it mentions tests passing locally but failing on deployment, the issue is usually SeeAllData=true (test relies on org data). System.assert is required — inserting a record without asserting is insufficient coverage.
- Async Apex questions: Identify the constraint: needs a callout from a trigger → Future. Needs chaining or SObject parameter → Queueable. Processes large datasets → Batch. Needs to run on a schedule → Scheduled. Needs to be monitored with status → Batch (has System.scheduleBatch and Apex Jobs UI).
- LWC questions: If a parent component needs to pass data to a child, use @api. If a child needs to notify a parent, fire a custom event with this.dispatchEvent(new CustomEvent('eventname', { detail: data })). If you need to call Apex imperatively, import the method and call it in connectedCallback() or a click handler.
Mock-Test Benchmark Before Booking
78%+ on 3 timed full mocks (60 Q / 110 min) before booking
PD1 passing score is 68%. The code-reading questions are designed to look ambiguous — a candidate who understands governor limits and bulkification can eliminate 2 of 4 answers immediately on most questions. If you are consistently failing governor limit questions, spend another week writing Apex in a Developer Edition org. Hands-on writing is the fastest way to internalise these patterns.
Top 10 Topics to Review the Day Before
- Governor limits: 100 SOQL, 150 DML, 50,000 rows, 10 callouts per synchronous transaction
- Bulkification pattern — SOQL/DML outside loops, use Collections and Maps
- Trigger.new vs Trigger.old vs Trigger.newMap/oldMap and when each is available
- Before trigger vs After trigger — before is used to set field values (no DML needed), after is used to query related records
- @isTest, Test.startTest/stopTest purpose — resets limits, forces async execution
- 75% code coverage minimum for deployment — calculated across org, not per class
- Future vs Queueable vs Batch vs Scheduled — constraints and use cases
- @AuraEnabled(cacheable=true) for @wire, @AuraEnabled for imperative calls
- with sharing vs without sharing — sharing rules enforcement on Apex classes
- REST callout pattern: HttpRequest, Http.send(), getStatusCode(), getBody()
Related Guides
Practice With Real Exam-Style Questions
Apply this study guide with free PD1 practice questions, exam weightage breakdown, and prep tips:
What Comes After This Certification?
After this certification, consider: Platform Developer II, Platform App Builder, or JavaScript Developer I.
Exam Section Difficulty Heatmap
Which sections are a gimme vs which ones trap confident candidates. Use this to prioritise your final-week revision.
| Exam Section | Difficulty | Study Tip |
|---|---|---|
| Data Modeling and Management | Moderate | SOQL relationship queries (parent-to-child, child-to-parent) and relationship field naming conventions. |
| Logic and Process Automation | Trap ⚠ | SOQL/DML inside loops — every loop in a code snippet should trigger a governor limit check. |
| User Interface | Moderate | LWC component lifecycle hooks (@wire, @api, @track) and when each is appropriate. |
| Testing, Debugging, and Deployment | Hard | System.assert() is required — coverage without assertions is meaningless. HttpCalloutMock for callout tests. |
| Integration and APIs | Hard | REST vs SOAP, Named Credentials, and when to use each integration pattern in a scenario. |
Difficulty based on analysis of common candidate errors across each exam section.
Ready to Test Your Knowledge?
Try the Platform Developer I (PD1) free practice exam — scored with full explanations.
Platform Developer I (PD1) Free Practice Exam →