Skip to main content
Trailblaze Prep

New to this track? Our Salesforce Certified Platform Foundations exam prep is the recommended first step. See our certification path to understand where this certification fits. The Salesforce Certified Platform Developer exam weights Process Automation and Logic most heavily (28%), see the full breakdown, study tips, and practice questions below.

The certification was previously known as Platform Developer I (PD1). Many candidates still search for “Platform Developer 1”, while the current official name is Salesforce Certified Platform Developer.

Quick Knowledge Check

A developer writes a trigger that runs a SOQL query inside a for loop. What governor limit risk does this create?

▶ Reveal answer

SOQL inside a loop will hit the 100 SOQL query limit if the loop iterates over more than 100 records. Fix: run one SOQL query before the loop using WHERE Id IN :idSet, store results in a Map<Id, SObject>, and look up records inside the loop with no additional queries.

Sample practice questions and answers are below ↓

Free sample questionsIndependent exam-prep resourceEditorial policyConfirm current details in the official guide
Start Free PD1 Practice (60Q, 105 min)

Free practice • No sign-up required

$200 exam • 68% passing score • Free practice

Request full PD1 mock exam & study plan

PD1Intermediate

Salesforce Certified Platform Developer I (PD1): Free Practice Exam & Study Guide (2026)

Platform Developer I (PD1) tests whether you can build custom applications on the Salesforce platform with Apex and Lightning Web Components: triggers and governor limits, asynchronous patterns, the data model, and test classes. The exam is 60 scored questions in 105 minutes, with a 68% pass mark, weighted towards Process Automation and Logic (28%) and Developer Fundamentals (27%).

Salesforce Certified Platform Developer exam quick facts
Official exam name and codeSalesforce Certified Platform Developer (PD1)
Questions60
Time allotted105 min
Passing score68%
Exam fee$200
Retake fee$100
Prerequisite certificationsRecommended preparation: Salesforce Certified Platform Foundations
Study guide releaseSummer '26

Salesforce Certified Platform Developer Exam Weightage by Section

1. Developer Fundamentals (27%)

27%

2. Process Automation and Logic (28%)

28%

3. User Interface (25%)

25%

4. Testing, Debugging, and Deployment (20%)

20%

Exam Topics

Apex FundamentalsData ModelingSOQL & SOSLDML OperationsTriggersVisualforceLightning ComponentsTestingDebug & DeploymentIntegration

Last updated:

Who is the Platform Developer I exam for?

  • Developers new to Salesforce: You have programming experience in Java, JavaScript, or another language and want to build on the Salesforce platform using Apex and LWC.
  • Admins transitioning to development: You passed ADM-201 and want to move beyond declarative tools into custom code, triggers, and integrations.
  • Full-stack developers at SI partners: Your firm requires PD1 certification for project staffing, and you need to validate Salesforce-specific development skills.

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

Maintenance and renewal requirements vary. Check the issuer’s current credential page for requirements that apply to you.

How to Register

Check current Salesforce Certified Platform Developer (PD1) credential and registration details with the issuer.

View official credential details

Official references: Use the issuer’s current materials to confirm exam objectives, format, and fees before booking.

Official sources: Exam guide·Salesforce exam pricing·Independent exam-prep resource; details may change.

Why This Certification Matters

PD1 is the standard developer cert.

It is required for many technical and architect paths.

Exam Tips

  • 1Logic and User Interface are 50% combined, Apex triggers, LWC, and when to use each.
  • 2Know governor limits: SOQL 100, DML 150, etc., and how to avoid hitting them.
  • 3Testing: minimum code coverage, positive and negative tests, Test.runAs().
  • 4Understand @AuraEnabled, @InvocableMethod, and when to use REST vs SOAP.

Prerequisites

  • •Programming experience (Java, C#, or similar)
  • •Administrator or App Builder recommended

Focus Areas

  • •Apex and Triggers
  • •Lightning Web Components
  • •Testing and Deployment
  • •Governor Limits

Study Strategy

Code daily in a dev org.

Build a small LWC + Apex feature and write tests.

Memorize key governor limits and practice debugging scenarios.

Exam Format and First-Attempt Readiness

The Salesforce Certified Platform Developer exam has 60 questions in 105 min, passing score 68%. Most Salesforce exams test scenario-based decisions. Focus on when to use each feature, not just terms.

  • Study Process Automation and Logic and Developer Fundamentals first, together they carry 55% 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 at 80%+.
Next: practice questions or certification path.
Suggested study timeline for PD1 (6–10 weeks)
Is the PD1 Exam Hard?
PD1 Exam Format Explained

Platform Developer I: Key Concepts for the Exam

Apex Governor Limits & the Limits Class

Governor limits prevent any one transaction from monopolising shared platform resources. Key synchronous limits: 100 SOQL queries, 150 DML statements, 50,000 records returned from queries, 6 MB heap size, 10 seconds CPU time. Asynchronous limits are generally 2× the synchronous limits. Use Limits.getQueries() and Limits.getLimitQueries() from the Apex Common Classes (the Limits class) to check usage at runtime. The exam tests which limit applies to a given code scenario and what to change.

Bulkification: Never Put SOQL or DML Inside a Loop

The core Apex pattern: query records before loops using a single SOQL with IN:triggerIdSet, collect changes in a List or Map inside loops, then perform DML after loops. Map<Id, SObject> is the workhorse, used to relate trigger records to queried related records by Id. Use Database.insert(records, false) for partial success (returns SaveResult array). The exam presents code with SOQL/DML in a loop and asks you to identify the issue or fix it.

Apex Triggers: Order of Execution & Handler Pattern

Before triggers fire before the record is saved. Use them to validate or modify field values before save (changes to Trigger.new persist without extra DML). After triggers fire after the record is committed. Use them when you need the record Id or to update related records. Key context variables: Trigger.new, Trigger.old (not available on insert), Trigger.isInsert, Trigger.isUpdate. Best practice: one trigger per object, all logic delegated to a handler class. The Order of Execution for a save: validation rules → before triggers → system validation → after triggers → workflow rules → DML commit → flows (record-triggered).

SOQL: Relationships, Aggregates & SOSL

Child-to-parent query: SELECT Id, Account.Name FROM Contact (dot notation). Parent-to-child: SELECT Id, (SELECT Id FROM Contacts) FROM Account (subquery). Aggregate functions: COUNT(), SUM(), AVG(), require GROUP BY. SOSL searches multiple objects simultaneously: FIND ’term’ IN ALL FIELDS RETURNING Account, Contact. Use SOSL for cross-object searches; use SOQL when you know the object.

Process Automation: Flow vs. Apex Triggers

The exam tests when to use declarative automation (Flow) vs. programmatic automation (Apex Triggers). Use Flow for standard CRUD operations, approval automation, and complex UI flows without code. Use Apex Triggers when you need cross-object logic beyond Flow’s capabilities, governor limit control, or callout scheduling. Both can fire on the same record, the Order of Execution determines which runs first (Flow runs before After Triggers in record-triggered contexts). Key PD1 topic: if Flow can do it declaratively, prefer Flow; if it needs Apex Classes, Limits, or Database class methods, use Apex.

Testing Framework: SeeAllData, Test.startTest & HttpCalloutMock

Minimum 75% code coverage required across all Apex to deploy to production. Test classes use @isTest. Test data is isolated by default (SeeAllData=false), create all test data explicitly using @TestSetup or within each test method. Test.startTest() resets governor limits and marks the start of the tested code; Test.stopTest() forces async operations (future methods, batch jobs) to complete synchronously. Mock HTTP callouts with Test.setMock(HttpCalloutMock.class, mockImpl). @TestVisible exposes private members to test classes without making them public.

Lightning Web Components (LWC): Wire Service & @AuraEnabled

LWC is the modern Salesforce UI framework. Key decorators: @track (reactive private properties), @api (public properties exposed to parent), @wire (reactive Apex method calls). The @wire decorator connects an LWC to an Apex method marked @AuraEnabled(cacheable=true), the cacheable flag is required for @wire. Use lightning-record-form for standard record CRUD without writing Apex. Communication between components uses CustomEvent (child to parent) and LightningMessageService (unrelated components).

Core Apex Code Patterns for PD1

The PD1 exam presents real Apex code in 30–40% of questions. These three patterns appear most frequently, understand them at a read-and-reason level, not just from a definition.

1. Bulk-Safe Trigger with Handler Class

One trigger per object, all logic in a handler class. SOQL runs once outside the loop; DML runs once after the loop.

// AccountTrigger.trigger
trigger AccountTrigger on Account (before insert, after insert) {
    AccountTriggerHandler handler = new AccountTriggerHandler();
    if (Trigger.isBefore && Trigger.isInsert) {
        handler.onBeforeInsert(Trigger.new);
    }
    if (Trigger.isAfter && Trigger.isInsert) {
        handler.onAfterInsert(Trigger.new);
    }
}
 
// AccountTriggerHandler.cls
public class AccountTriggerHandler {
    public void onBeforeInsert(List<Account> newAccounts) {
        // Validate or set field values, no DML needed, changes persist
        for (Account acc : newAccounts) {
            if (acc.Industry == null) {
                acc.Industry = 'Technology';
            }
        }
    }
 
    public void onAfterInsert(List<Account> newAccounts) {
        // Collect Ids, run one SOQL, perform one DML outside loop
        Set<Id> accountIds = new Map<Id, Account>(newAccounts).keySet();
        List<Contact> contacts = [SELECT Id, AccountId FROM Contact
                                   WHERE AccountId IN :accountIds];
        List<Contact> toUpdate = new List<Contact>();
        for (Contact c : contacts) {
            c.Description = 'Processed';
            toUpdate.add(c);
        }
        update toUpdate; // Single DML, not inside loop
    }
}

2. Database Class with Partial Success & Error Handling

Use Database.insert(records, false) to allow partial success; inspect the SaveResult array for errors.

List<Account> accountsToInsert = new List<Account>();
accountsToInsert.add(new Account(Name = 'Valid Account'));
accountsToInsert.add(new Account()); // Missing required field, will fail
 
// allOrNone = false → partial success allowed
Database.SaveResult[] results = Database.insert(accountsToInsert, false);
 
for (Database.SaveResult sr : results) {
    if (sr.isSuccess()) {
        System.debug('Inserted: ' + sr.getId());
    } else {
        for (Database.Error err : sr.getErrors()) {
            System.debug('Error: ' + err.getMessage()
                       + ' Fields: ' + err.getFields());
        }
    }
}

3. Test Class with HttpCalloutMock

HTTP callouts cannot run in tests, implement HttpCalloutMock and register it with Test.setMock().

// Mock implementation
@isTest
global class MockHttpCallout implements HttpCalloutMock {
    global HTTPResponse respond(HTTPRequest req) {
        HttpResponse res = new HttpResponse();
        res.setHeader('Content-Type', 'application/json');
        res.setBody('{"status":"success"}');
        res.setStatusCode(200);
        return res;
    }
}
 
// Test class
@isTest
private class CalloutServiceTest {
    @isTest
    static void testCalloutSuccess() {
        Test.setMock(HttpCalloutMock.class, new MockHttpCallout());
        Test.startTest();
        String result = CalloutService.makeCallout('https://api.example.com');
        Test.stopTest(); // Forces async to complete
        System.assertEquals('success', result, 'Expected success status');
    }
}
Execution context: Triggers, Flow, and Process Builder share one transaction (exam mental model)

All automation that fires on a single DML operation, before/after triggers, Record-Triggered Flows, and Process Builder, runs inside one execution context. Governor limits (SOQL queries, DML statements, CPU time) accumulate across all of them, not per-automation. This is why bulkification and avoiding recursive updates matters for PD1.

Diagram: a single transaction execution context boundary contains before triggers, validation, after triggers, Record-Triggered Flow, and Process Builder, all sharing one shared governor limit poolOne Transaction / Execution Context(one shared governor-limit pool for everything inside this box)Before TriggerField defaults, validationRecord Saved(not yet committed)After TriggerRelated record updatesRecord-Triggered FlowRuns in the same transactionProcess Builder (legacy)Also shares the same contextIf a Flow/Process re-updates the record, before/after triggers can re-fire. Watch for recursionGovernor limits (100 SOQL, 150 DML, CPU time) apply to the WHOLE box above, not per automation

How to Pass the Platform Developer I (PD1) Exam

PD1 is a code-heavy exam where most questions present Apex code or describe a development scenario and ask you to identify the issue, fix, or best practice. Understanding governor limits, bulkification patterns, and test methodology at a deep practical level is what separates passing candidates from failing ones.

Governor Limit Questions, the Pattern to Recognise

The exam will show you Apex code and ask “what is wrong with this code?” The answer is almost always SOQL or DML inside a for loop. Look for for (Account a: accounts) { insert contact; }, that’s DML in a loop, and it will hit the 150 DML statement limit. The fix: collect records in a List inside the loop, then call insert contactList; after the loop. For SOQL: use Maps populated with a single query before the loop, not a query inside the loop.

Testing Questions, the Three Rules to Memorise

(1) Minimum 75% code coverage across the entire org (not per class) to deploy. (2) Test data must be created in the test method, do not rely on org data (@isTest(SeeAllData=false) is the default). (3) HTTP callout tests require a mock implementation, use Test.setMock(HttpCalloutMock.class, mockImpl). Questions often say “a developer’s test class fails when calling an external API” the answer is always to implement HttpCalloutMock.

Async Apex Selection: Which Method for Which Scenario

Use Future methods for simple one-off async operations (HTTP callouts from triggers, mixed DML). Use Batch Apex when processing more than 10,000 records (up to 50 million). Use Queueable Apex when you need chaining (one job triggers another) or need to pass complex objects between async contexts. Use Scheduled Apex for time-based execution. Exam tip: if the question says “millions of records” or “process in chunks” the answer is Batch Apex. If it says “chain jobs”: Queueable.

Trigger Scenarios: Before vs After

When the question says “set a field value before the record is saved” use a before trigger (changes to Trigger.new persist without a DML call). When the question says “create a related record after an account is created” use an after trigger (the account Id exists after save). When the question says “prevent a record from being saved if a condition is not met” use addError() in a before trigger. Never call a SOQL query in a trigger without first checking bulkification patterns.

Exam Strategy

PD1 questions often include realistic-looking Apex code snippets. Read code carefully, the “wrong answer” in the options often uses the right method name but in the wrong context (e.g., using a future method where a queueable is needed, or using DML before a callout). Passing score is 68% (41/60 questions). Aim for 80%+ on full mock exams, the additional buffer accounts for exam-day stress and unfamiliar question phrasing. Complete the official Trailhead PD1 Trailmix before booking.

Is the Salesforce Certified Platform Developer (PD1) Exam Hard?

DifficultyChallenging; plan about 8-16 weeks of focused prep.

Book When ReadyScore 80%+ on three timed mocks before scheduling.

Use Practice, Not DumpsOriginal practice questions build skill without risking your credential.

Exam format: 60 questions, 105 min, 68% passing score.

Salesforce Certified Platform Developer Practice Questions (With Explanations)

Test your knowledge with these 15 sample questions . Select the requested number of answers, then check your selection.

Question 1: A developer needs to create a trigger that fires after a record is inserted and updated. Which trigger events should be used?

Key takeaway: The 'after insert' and 'after update' trigger events fire after the record is saved to the database, which is required when you need to access the record Id or related records.

Show correct answer and explanation

Correct answer: A. after insert, after update

The 'after insert' and 'after update' trigger events fire after the record is saved to the database, which is required when you need to access the record Id or related records.

  • 'before insert, before update' fires prior to save, when the record doesn't yet have an Id, insufficient for logic needing the saved record or related records.
  • 'after insert, before update' mixes timing incorrectly for this scenario's need to run after both operations.
  • 'isInsert, isUpdate' are trigger context variables, not trigger event names, this option misidentifies the concept being asked about.

Question 2: What is the governor limit for the maximum number of SOQL queries in a single transaction?

Key takeaway: The synchronous governor limit for SOQL queries is 100 per transaction.

Show correct answer and explanation

Correct answer: B. 100 queries

The synchronous governor limit for SOQL queries is 100 per transaction. For asynchronous contexts, the limit is 200.

  • 50 understates the actual synchronous SOQL limit of 100.
  • 150 overstates the actual synchronous SOQL limit of 100.
  • 200 is the asynchronous limit, not the synchronous limit this question asks about.

Question 3: Which annotation is used to expose an Apex method as a REST web service?

Key takeaway: The @RestResource annotation is used at the class level to expose an Apex class as a REST resource.

Show correct answer and explanation

Correct answer: A. @RestResource

The @RestResource annotation is used at the class level to expose an Apex class as a REST resource. Individual methods use @HttpGet, @HttpPost, etc.

  • @HttpGet is a method-level annotation for REST verbs, not the class-level annotation that exposes the class itself as a REST resource.
  • @RemoteAction exposes Apex to Visualforce remoting, unrelated to REST web services.
  • @AuraEnabled exposes methods to Lightning components, not REST API consumers.

Question 4: A developer writes a SOQL query: SELECT Id, Name FROM Account WHERE Name LIKE '%tech%'. What will this query return?

Key takeaway: The % wildcard matches any number of characters.

Show correct answer and explanation

Correct answer: C. Accounts where Name contains 'tech'

The % wildcard matches any number of characters. Using %tech% matches any Account where the Name contains 'tech' anywhere in the string.

  • 'starts with' would require the pattern 'tech%' (no leading wildcard), not '%tech%'.
  • 'ends with' would require the pattern '%tech' (no trailing wildcard), not '%tech%'.
  • 'equals' would require no wildcards at all: LIKE with wildcards never means exact equality.

Question 5: Which method should be used to perform DML operations inside a for loop safely?

Key takeaway: To avoid hitting governor limits, you should always collect records in a list during the loop and perform DML operations outside the loop (bulk processing).

Show correct answer and explanation

Correct answer: C. Collect records in a list and perform DML outside the loop

To avoid hitting governor limits, you should always collect records in a list during the loop and perform DML operations outside the loop (bulk processing).

  • Database.insert() alone doesn't address the loop-placement issue: DML inside a loop is the problem regardless of which insert method is used.
  • A plain insert statement inside a loop has the same governor-limit risk as any DML call inside a loop.
  • @future methods don't solve bulkification, they move work asynchronously but don't fix DML-in-a-loop patterns.

Question 6: What is the minimum code coverage required for Apex classes and triggers to be deployed to production?

Key takeaway: Salesforce requires at least 75% code coverage for Apex classes and triggers to be deployed to production.

Show correct answer and explanation

Correct answer: B. 75%

Salesforce requires at least 75% code coverage for Apex classes and triggers to be deployed to production. This ensures code quality and reliability.

  • 60% is below Salesforce's actual required threshold of 75%.
  • 80% overstates the actual required minimum, though it's often recommended as a safety margin.
  • 100% is not required by Salesforce, though desirable in some rigorous engineering practices.

Question 7: Which annotation is used to make an Apex method available to Lightning Web Components?

Key takeaway: The @AuraEnabled annotation makes an Apex method available to Lightning Web Components (LWC) and Aura components, allowing them to call server-side logic.

Show correct answer and explanation

Correct answer: A. @AuraEnabled

The @AuraEnabled annotation makes an Apex method available to Lightning Web Components (LWC) and Aura components, allowing them to call server-side logic.

  • @RemoteAction exposes methods to Visualforce remoting, not modern LWC/Aura components.
  • @RestResource exposes a class as a REST API endpoint, unrelated to LWC method calls.
  • @InvocableMethod exposes Apex to Flow and Process Builder, not LWC.

Question 8: A developer wants to create a trigger that processes records in bulk. What is the best practice?

Key takeaway: Best practice is to collect records in a list during iteration and process them in bulk outside the loop to avoid hitting governor limits.

Show correct answer and explanation

Correct answer: B. Collect records in a list and process outside the loop

Best practice is to collect records in a list during iteration and process them in bulk outside the loop to avoid hitting governor limits.

  • Processing one record at a time in a loop is the anti-pattern that causes governor limit issues, not the best practice.
  • @future methods don't solve bulkification, they simply defer execution asynchronously.
  • 'Synchronous methods only' doesn't address the bulk-processing requirement at all.

Question 9: What is the governor limit for DML statements in a single transaction?

Key takeaway: The synchronous governor limit for DML statements (insert, update, delete, upsert, etc.

Show correct answer and explanation

Correct answer: B. 150 DML statements

The synchronous governor limit for DML statements (insert, update, delete, upsert, etc.) is 150 per transaction.

  • 100 DML statements understates the actual synchronous limit of 150.
  • 200 DML statements overstates the actual synchronous limit of 150.
  • The DML statement limit is not unlimited: Salesforce enforces a specific cap to protect the multi-tenant platform.

Question 10: Which method is used to handle partial success in DML operations?

Key takeaway: Database.

Show correct answer and explanation

Correct answer: A. Database.insert()

Database.insert() returns a Database.SaveResult array, allowing you to handle partial success. The insert statement throws an exception if any record fails.

  • A plain insert statement throws an exception on any failure, it doesn't support partial success handling.
  • 'Database.insert() with allOrNone parameter' set to true behaves like the plain insert statement (all-or-nothing); it's the default false setting on Database.insert() that enables partial success.
  • 'All of the above' is incorrect since the plain insert statement specifically does NOT support partial success.

Question 11: What is the purpose of Test.runAs() in Apex test classes?

Key takeaway: Test.

Show correct answer and explanation

Correct answer: A. To test with different user permissions

Test.runAs() allows you to execute test code in the context of a specific user, enabling you to test with different user permissions and sharing rules.

  • Test.runAs() doesn't test asynchronous code, that's unrelated to its purpose of switching user context.
  • Test.runAs() isn't specific to batch class testing, it applies to any Apex test scenario needing a different user context.
  • Test.runAs() isn't specific to trigger testing, it's a general user-context testing mechanism usable anywhere.

Question 12: Which exception type should be thrown when validation fails in Apex?

Key takeaway: DmlException is thrown when DML operations fail.

Show correct answer and explanation

Correct answer: B. DmlException

DmlException is thrown when DML operations fail. For custom validation errors, you can throw DmlException with a custom message.

  • A generic Exception doesn't carry the DML-specific context that DmlException provides for failed database operations.
  • AuraHandledException is specifically for surfacing errors to Lightning components, not general DML failure handling.
  • A custom exception class can be used, but DmlException is the standard, built-in type specifically for DML failures.

Question 13: A developer wants to query related records in a single SOQL query. Which clause should be used?

Key takeaway: SOQL uses relationship queries (dot notation) to query related records, such as 'SELECT Id, Account.

Show correct answer and explanation

Correct answer: C. Relationship query (dot notation)

SOQL uses relationship queries (dot notation) to query related records, such as 'SELECT Id, Account.Name FROM Contact' to get the Account name for each Contact.

  • JOIN is not valid SOQL syntax: SOQL uses relationship dot-notation instead of SQL-style joins.
  • INNER JOIN is SQL syntax, not valid SOQL: Salesforce's query language doesn't support this keyword.
  • A subquery (parent-to-child) is a different SOQL technique for retrieving child records, not the dot-notation syntax used for the parent-to-child scenario described here.

Question 14: What is the purpose of the @TestVisible annotation?

Key takeaway: @TestVisible allows test classes to access private methods and variables, enabling better test coverage without making them public.

Show correct answer and explanation

Correct answer: B. To make a private method or variable accessible to test classes

@TestVisible allows test classes to access private methods and variables, enabling better test coverage without making them public.

  • 'To make a method available to test classes' is too broad; @TestVisible specifically exposes private members, not general method availability.
  • @TestVisible doesn't mark a class as a test class, that's unrelated to its actual purpose.
  • @TestVisible doesn't enable test coverage tracking, that's a platform-level, automatic measurement, not something this annotation controls.

Question 15: Which governor limit applies to the number of records processed in a single transaction?

Key takeaway: The governor limit for the number of records processed in a single transaction is 200,000 records for synchronous contexts and 1,000,000 for asynchronous contexts.

Show correct answer and explanation

Correct answer: D. 200,000 records

The governor limit for the number of records processed in a single transaction is 200,000 records for synchronous contexts and 1,000,000 for asynchronous contexts.

  • 10,000 records understates the actual synchronous governor limit of 200,000.
  • 50,000 records understates the actual synchronous governor limit of 200,000.
  • 100,000 records understates the actual synchronous governor limit of 200,000.

Get the Full PD1 Question Bank

Most candidates book the exam after scoring 80%+ 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.

Contact us for more information on our full 60-question mock exams and a personalized study plan. Use the contact form.

Request Mock Exams & Study Plan

PD1 Study Resources

Coming from the admin track? ADM-201 exam tips (Summer '26) covers the Salesforce fundamentals that overlap with PD1.

Salesforce Certified Platform Developer (PD1) Exam FAQs

What is covered on the Salesforce Certified Platform Developer (PD1) exam?
The Salesforce Certified Platform Developer (PD1) exam (formerly Salesforce Certified Platform Developer I) 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 programming languages do I need to know for Platform Developer I?
You need to know Apex (Salesforce's Java-like language) and JavaScript for Lightning Web Components. Experience with Java, C#, or similar object-oriented languages is helpful, but you can learn Apex through Trailhead and hands-on practice.
How much coding experience do I need for Platform Developer I?
While some programming experience is helpful, you can learn Apex and Lightning Web Components through Trailhead. The exam focuses on understanding when to use code vs declarative tools, governor limits, testing, and basic Apex/LWC concepts rather than advanced programming.
What is the PD1 passing score and exam format in Summer '26?
The Platform Developer I (PD1) exam has 60 multiple-choice questions, 105 minutes, and a passing score of 68% (41 correct). Salesforce may include 5 unscored pilot questions. The exam costs $200 USD (retake $100 USD) and is available online-proctored or at a test center.
What are the most common reasons candidates fail PD1?
Common failure points: (1) not knowing governor limits (SOQL 100/transaction, DML 150/transaction) and when they trigger, (2) writing DML or SOQL inside a for loop, the exam's most common trap, (3) misunderstanding the 75% code coverage rule and how Test.startTest()/stopTest() affect limit resets, and (4) confusing @AuraEnabled, @RestResource, and @InvocableMethod annotations.

Honest Cert Breakdown

4

Difficulty: Hard

4/5

Apex, 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 Summer '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

105 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 Logic and Developer Fundamentals together account for 55% of the exam. Master Apex and the platform data model first.

Process Automation and Logic30%

Apex classes, triggers, governor limits, bulkification, async Apex (Future, Batch, Queueable, Scheduled)

Testing, Debugging, and Deployment25%

Test classes, @isTest, Test.startTest/stopTest, code coverage (75% minimum), debugging tools, change sets, metadata API

User Interface23%

Lightning Web Components (LWC), Aura components, Visualforce basics, @wire service, lightning-record-form, JavaScript in LWC

Integration15%

REST vs SOAP callouts, HttpRequest, HTTP methods (GET/POST/PUT/DELETE), JSON parsing, Named Credentials, external services

Salesforce Fundamentals7%

Platform basics, MVC pattern, declarative vs programmatic, object relationships, sharing model fundamentals

What Each Section Actually Tests

Process Automation and Logic (28%)

The heart of the PD1 exam. Apex governor limits are per transaction: SOQL is limited to 100 queries synchronously and 200 asynchronously; DML statements to 150; and records retrieved by SOQL queries to 50,000. CPU time is limited to 10,000ms synchronously and 60,000ms asynchronously. The callout limit is 100 per transaction. 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. These are general per-transaction limits; the applicable context and documented exceptions matter, and exceeding a governor limit can cause an unhandled runtime exception. 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.

Verify current values and context-specific exceptions in Salesforce's Apex Governor Limits quick reference and Execution Governors and Limits.

Testing, Debugging, and Deployment (20%)

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 (25%)

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 (tested within Process Automation and Logic)

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). Apex allows 100 callouts per transaction.

Developer Fundamentals (27%)

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 / 105 min), weak-area targeted revision. Score 80%+ 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.

How to Know You’re Ready

80%+ on 3 timed full mocks (60 Q / 105 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

  1. Governor limits per transaction: SOQL 100 synchronous / 200 asynchronous; DML 150; SOQL-retrieved rows 50,000; callouts 100; CPU 10,000ms synchronous / 60,000ms asynchronous
  2. Bulkification pattern: SOQL/DML outside loops, use Collections and Maps
  3. Trigger.new vs Trigger.old vs Trigger.newMap/oldMap and when each is available
  4. Before trigger vs After trigger; before is used to set field values (no DML needed), after is used to query related records
  5. @isTest, Test.startTest/stopTest purpose, resets limits, forces async execution
  6. 75% code coverage minimum for deployment, calculated across org, not per class
  7. Future vs Queueable vs Batch vs Scheduled, constraints and use cases
  8. @AuraEnabled(cacheable=true) for @wire, @AuraEnabled for imperative calls
  9. with sharing vs without sharing, sharing rules enforcement on Apex classes
  10. REST callout pattern: HttpRequest, Http.send(), getStatusCode(), getBody()

Related Guides

PD1 Exam Tips Summer '26PD1 vs PD2 ComparisonApp Builder Study GuideDeveloper Certification Path

Practice With Real Exam-Style Questions

Apply this study guide with free PD1 practice questions, exam weightage breakdown, and prep tips:

PD1 Practice QuestionsPD1 Exam Tips Summer '26Developer Cert Path

Your Next Certification Step

After this certification, consider: Platform Developer II, Platform App Builder, or JavaScript Developer I.

Topic Difficulty Heatmap

Which topics are a gimme vs which ones trap confident candidates. Use this to prioritise your final-week revision. These are our own topic groupings for study planning, not the official exam sections, those and their weightings are in the credential's exam guide.

TopicDifficultyStudy Tip
Data Modeling and ManagementModerateSOQL relationship queries (parent-to-child, child-to-parent) and relationship field naming conventions.
Logic and Process AutomationTrap ⚠SOQL/DML inside loops, every loop in a code snippet should trigger a governor limit check.
User InterfaceModerateLWC component lifecycle hooks (@wire, @api, @track) and when each is appropriate.
Testing, Debugging, and DeploymentHardSystem.assert() is required, coverage without assertions is meaningless. HttpCalloutMock for callout tests.
Integration and APIsHardREST 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 →

Quick Answer: Best Way to Pass PD1

  • Logic and Process Automation is 28% of the exam, master Apex triggers, governor limits, and async patterns first.
  • Write real Apex code every day. PD1 scenarios require you to identify bugs and select correct patterns, not just recall facts.
  • Take timed mocks (60 questions / 105 minutes). You are ready when you consistently score 80%+, the passing score is 68%.

PD1 Exam Weightage at a Glance

Focus time proportionally. The top three sections cover 73% of the exam.

Logic and Process Automation28%

Apex, triggers, async (Future, Batch, Queueable)

Salesforce Fundamentals23%

Platform concepts, data model, security model

Data Modeling and Management22%

SOQL, SOSL, DML, relationships, schema

Testing, Debugging, and Deployment14%

75% coverage rule, Test.runAs(), debugging tools

User Interface13%

LWC basics, @AuraEnabled, Lightning Data Service

Governor Limits You Must Know Cold

PD1 tests governor limits directly and through scenario questions. Memorise these before exam day:

LimitSynchronousAsynchronous
SOQL queries per transaction100200
DML statements per transaction150150
Records per DML operation10,00010,000
Total records retrieved by SOQL50,00050,000
Apex CPU time10,000 ms60,000 ms

The exam will ask you to identify code that violates these limits, especially SOQL/DML inside for loops.

4-Week PD1 Study Plan

Week 1: Salesforce Fundamentals & Data Modeling (45%): Platform data model, object relationships (lookup vs master-detail), field types, schema builder, SOQL (relationship queries, aggregate functions, dynamic SOQL), SOSL, and DML operations.

Week 2: Logic and Process Automation (28%): Apex fundamentals, trigger events (before/after, isNew, isUpdate, isDelete), bulkification patterns, governor limits, async Apex (Future, Batch, Queueable, Scheduled), and error handling.

Week 3: Testing, Deployment & UI (27%): Writing @isTest classes, Test.startTest()/stopTest(), Test.runAs(), mock data, 75% coverage requirement, debugging logs, changeset/metadata deployment, and LWC fundamentals (@api, @wire, @AuraEnabled).

Week 4: Full timed mock exams (60 Q / 105 min), weak-area targeted revision, and final review of governor limit scenarios before booking.

How to Handle PD1 Scenario Questions

Most PD1 questions give you a code snippet or business requirement and ask you to identify the problem or select the best implementation. Two strategies work here:

  • Code review questions: Look for DML or SOQL inside a loop first; that is the most common governor limit trap. If you see it, the answer involves moving operations outside the loop.
  • Requirement questions: Map the requirement to the right async tool. Use Future for single-record callouts, Batch for large data volumes, Queueable for chaining jobs, and Scheduled for time-based execution.
  • Testing questions: If the scenario asks about code coverage or test data, remember: 75% overall is required, @TestVisible exposes private members, and Test.runAs() tests user-context behaviour.

Booking Readiness Benchmark

PD1 passing score is 68% (41/60 questions). Use this benchmark before scheduling:

80%+ on 3 timed full mocks (60 Q / 105 min), one week apart

The 10-point buffer above the passing score accounts for first-attempt nerves and unfamiliar question phrasing. If you are failing the Logic & Process Automation questions consistently, spend another week on triggers and async Apex before booking.

3 Concepts That Fail Most PD1 Candidates

These are not the hardest topics; they are the ones where candidates are most confidently wrong. Learn the distinction early.

1. SOQL Inside For-Loops: The Governor Limit That Kills Your Score

The 101-query governor limit means any SOQL statement inside a loop will fail at runtime when processing more than 100 records. Exam scenarios show code snippets and ask you to identify the bug. The wrong-answer trap is selecting “reduce batch size” the correct fix is always “move the SOQL outside the loop and use a Map or List.” Train yourself to scan every for-loop in a code snippet and ask: is there a SOQL or DML statement inside?

2. @wire vs @api vs @track: One Wrong Decorator, One Wrong Answer

LWC decorator questions are a guaranteed exam topic. @wire connects a property to a Salesforce data service (Apex or UI API) reactively. @api exposes a property or method to a parent component; it is public. @track is largely deprecated in modern LWC; plain properties are now reactive by default. The trap: candidates use @track thinking it makes a property “reactive” when @wire is what actually connects to the server.

3. Test Classes: Coverage Is Not Enough: Assertions Are Required

A test class that runs code and hits 75% coverage but contains no System.assert() statements is considered invalid for certification purposes. Exam questions often show a test method and ask what is wrong; the correct answer is “no assertions” even if coverage looks sufficient. Also know: callout mocks require HttpCalloutMock implementation, and calling a real endpoint in a test will throw an exception, not just fail silently.

Questions Candidates Ask

What is the PD1 exam format?

The Salesforce Platform Developer I exam (CRT-450) has 60 multiple-choice questions, a 105-minute time limit, a 68% passing score, and a $200 exam fee.

What are the highest-weight PD1 topics?

Logic and Process Automation (38%) is the largest section on PD1, followed by Data Management and Integration (11%). Focus on governor limits, trigger best practices, Apex patterns, and bulkification.

How long does it take to prepare for PD1?

6–8 weeks with daily coding practice. Writing Apex code hands-on is essential, candidates who only read Trailhead without practising tend to struggle with scenario questions.

What is the hardest part of the PD1 exam?

Governor limits and bulkification. Every Apex scenario expects bulk-safe code, no SOQL or DML inside loops, use of Maps and Sets for batch operations, and correct trigger context variable usage.

What concepts do most PD1 candidates get wrong?

The most commonly misunderstood topics for the PD1 exam are: (1) SOQL Inside For-Loops: The Governor Limit That Kills Your Score; (2) @wire vs @api vs @track: One Wrong Decorator, One Wrong Answer; (3) Test Classes: Coverage Is Not Enough: Assertions Are Required. Candidates are most confidently wrong on these. Learn the distinctions early to avoid losing marks on questions you expect to get right.

Why do most PD1 candidates fail questions about SOQL Inside For-Loops: The Governor Limit That Kills...?

The 101-query governor limit means any SOQL statement inside a loop will fail at runtime when processing more than 100 records. Exam scenarios show code snippets and ask you to identify the bug. The wrong-answer trap is selecting "reduce batch size", the correct fix is always "move the SOQL outside the loop and use a Map or List." Train yourself to scan every for-loop in a code snippet and ask...

Why do most PD1 candidates fail questions about @wire vs @api vs @track: One Wrong Decorator, One Wr...?

LWC decorator questions are a guaranteed exam topic. @wire connects a property to a Salesforce data service (Apex or UI API) reactively. @api exposes a property or method to a parent component; it is public. @track is l...

Why do most PD1 candidates fail questions about Test Classes: Coverage Is Not Enough?

A test class that runs code and hits 75% coverage but contains no System.assert() statements is considered invalid for certification purposes. Exam questions often show a test method and ask what is wrong; the correct answer is "no assertions" even if coverage looks sufficient. Also know: callout mocks require

Related Study Resources

PD2 Exam TipsJavaScript Developer I Exam TipsApp Builder Exam TipsDeveloper Certification Path

Next Step

Apply these tips with real exam-style practice questions:

Start PD1 Practice TestFull Developer Certification PathWhat Comes After PD1? PD2 →

After this exam, consider Platform Developer II or Platform App Builder next.

Share or cite this study guide

Free to link from a forum post, study repo or article. Copy the Markdown and paste it anywhere.