Salesforce Platform Developer I Certification: Complete Study Guide 2026

The Salesforce Platform Developer I (PDI) certification is the most important credential in the Salesforce developer ecosystem. It signals to employers that you have a verified, baseline understanding of Apex, SOQL, Lightning Web Components, and the Salesforce deployment model. This guide gives you everything you need to pass on your first attempt.

About the PDI Exam

Key exam logistics you need to know:

• Format: 60 multiple-choice and multi-select questions
• Duration: 105 minutes
• Passing score: 65% (39 correct answers out of 60)
• Cost: US$200 first attempt; US$100 retake
• Mode: Online proctored or Kryterion testing centers
• Prerequisites: None (though Salesforce Admin knowledge helps)
• Validity: Lifetime, with annual maintenance exams (free) for each release

Exam Topic Breakdown

Salesforce publishes the official exam guide (highly recommended reading). The approximate topic weights are:

• Apex (25%): Classes, triggers, SOQL, DML, governor limits, async Apex
• Process Automation & Logic (25%): Flows, formulas, validation rules, when to code vs. configure
• UI Development (25%): Lightning Web Components, Aura basics, Visualforce fundamentals
• Testing, Debugging, Deployment (14%): Test classes, Developer Console, sandbox types, change sets
• Developer Fundamentals (11%): Data model, relationships, sandbox vs. production, multitenancy

Apex Fundamentals — The Core 25%

This section tests your understanding of Apex syntax, execution model, and governor limits. Expect questions on:

• Data types and collections: List, Set, Map — when to use each, initializing, iterating
• SOQL in Apex: Inline queries, bind variables, aggregate queries, relationship queries
• DML operations: insert/update/delete/upsert, DML exceptions, Database methods vs. DML statements
• Governor limits: SOQL query limit (100 sync), DML limit (150), heap size (6MB sync), CPU time (10s sync)
• Async Apex: Future methods (@future), Batch Apex, Queueable, Scheduled Apex — when to use each

// Classic exam question pattern: Database.insert vs insert statement
// insert throws exception on partial failure
// Database.insert with allOrNone=false allows partial success

List<Account> accounts = new List<Account>{ acc1, acc2, acc3 };

// Option 1: all-or-nothing
insert accounts; // DmlException if any fail

// Option 2: partial success allowed
List<Database.SaveResult> results = Database.insert(accounts, false);
for (Database.SaveResult sr : results) {
    if (!sr.isSuccess()) {
        // handle individual failure
    }
}

Common trap questions: @future methods cannot call other @future methods. Batch Apex has its own governor limits per execute() call. Test.startTest() resets governor limits — use it to test async code.

UI Development — The Other Core 25%

The exam tests LWC (primary), Aura Components (secondary), and Visualforce (minor). Focus on LWC — it's the modern standard and has the most exam weight.

Key LWC concepts to know:

• Component structure: HTML template, JavaScript controller, CSS, metadata XML
• Data binding: one-way ({value}) vs. two-way (tracked properties)
• Component communication: parent-to-child (properties), child-to-parent (events), sibling (LMS)
• Wire service: @wire decorator for reading Salesforce data declaratively
• Imperative Apex calls: calling Apex methods directly from JavaScript
• Standard navigation: NavigationMixin for record pages and app navigation

// LWC wire vs imperative — exam distinguishes between these
import { LightningElement, wire } from 'lwc';
import getAccount from '@salesforce/apex/AccountController.getAccount';

export default class MyComponent extends LightningElement {
    @wire(getAccount, { accountId: '$recordId' })
    account; // reactive — updates when recordId changes
}

Testing — 14% but Often the Deciding Factor

Many candidates underestimate the Testing section and lose exam points that they should win. Key facts the exam tests:

• 75% code coverage is required to deploy to production (whole org, not per class)
• @isTest annotation on both the test class and test methods
• Test.startTest() and Test.stopTest() reset governor limits and force async completion
• @TestSetup runs once before all test methods in a class
• Test classes do NOT have access to org data by default; use @isTest(SeeAllData=true) sparingly
• System.assertEquals(expected, actual, message) — expected is the first parameter

Debugging & Deployment — 11%

The exam expects you to know the difference between sandbox types and when to use change sets vs. packages:

• Developer Sandbox: 200MB data, refreshes monthly, for development
• Partial Copy Sandbox: 5GB data, refreshes every 5 days, for testing with real data samples
• Full Copy Sandbox: Full production data copy, refreshes every 29 days, for UAT/load testing
• Change Sets: Point-and-click deployment tool, good for small changes, requires Deployment Connection
• Salesforce DX (SFDX): CLI-based deployment using metadata format, source-tracking, scratch orgs

The 4-Week Study Plan

This plan assumes 1–2 hours of study per day:

• Week 1 — Apex core: Complete the "Apex Basics & Database" Trailhead module. Read the Apex Developer Guide chapters on triggers and governor limits. Practice 20–30 Apex coding problems on a platform like ApexArena.
• Week 2 — UI and configuration: Complete the "Lightning Web Components" and "Flow" Trailhead modules. Build a simple LWC component in your Developer Edition org.
• Week 3 — Testing and deployment: Write test classes for your Apex code. Complete the "Apex Testing" and "Application Lifecycle and Development Models" Trailhead modules.
• Week 4 — Review and practice exams: Take 2–3 full-length practice exams (Trailhead, Focus on Force, or Salesforce Ben). Review every question you got wrong. Revisit your weakest topics. Schedule the real exam for day 28 or 29.

Exam Day Tips

• Flag and return: You can flag questions to revisit. Flag anything you're unsure about, complete the rest, then return to flagged questions.
• Eliminate obviously wrong answers: Most questions have 2 clearly wrong answers. Getting to a 50/50 choice significantly improves your odds.
• Watch for "EXCEPT" questions: Questions asking which option is NOT true are easy to misread under time pressure.
• Trust your preparation: If you've completed the Trailhead modules, practiced coding problems, and scored 70%+ on practice exams, you're ready.
• Time management: 105 minutes for 60 questions = 1 min 45 sec per question. Don't spend more than 3 minutes on any single question.