Salesforce Platform Developer 1 Exam Study Guide

What is the passing score for the Salesforce Platform Developer 1 exam?

The Salesforce Certified Platform Developer I exam requires a score of 65% to pass. The exam contains 60 multiple-choice questions with a 110-minute time limit. It tests Apex programming, Visualforce, Lightning Web Components, data modeling, testing frameworks, and Salesforce development best practices. Candidates with hands-on Apex and LWC development experience alongside platform configuration knowledge perform best.

---

The Salesforce Certified Platform Developer I (PDI) credential is the entry point for developer-track certifications in the Salesforce ecosystem. It validates that a developer can build and deploy custom business logic on the Salesforce platform using Apex, Visualforce, and Lightning Web Components (LWC), working within the declarative platform boundaries and understanding when to use code vs. configuration.

As of 2024, Salesforce reports that Platform Developer I is among the top five most sought-after Salesforce certifications in job postings, frequently listed alongside Administrator certification as a prerequisite for full-stack Salesforce developer roles. The credential is also a prerequisite for the Platform Developer II certification and carries weight in consultant and ISV (Independent Software Vendor) career paths.

This guide covers every exam topic, the depth of knowledge required, and a preparation strategy aligned to the official exam guide.

---

Exam Overview and Blueprint

Salesforce publishes an official exam guide for every certification. The PDI exam guide establishes the topic weights that determine where to invest preparation time.

Topic Area	Weight
Salesforce Fundamentals	7%
Data Modeling and Management	13%
Process Automation and Logic	13%
User Interface	23%
Testing, Debugging, and Deployment	20%
Apex	24%

Apex and User Interface together account for 47% of the exam. Testing and Deployment adds another 20%. These three areas -- Apex, UI development, and testing/deployment -- are where candidates who underperform typically have the largest gaps.

---

Salesforce Fundamentals (7%)

This domain establishes the conceptual foundation for developer-specific topics. It assumes some familiarity with the Salesforce platform as covered in the Administrator certification.

Key Concepts

Multi-tenant architecture: Salesforce is a multi-tenant platform where all customers share the same infrastructure. This architectural constraint drives governor limits -- the execution boundaries that prevent any single tenant from consuming disproportionate resources.

Governor limits -- constraints enforced by the Salesforce runtime engine that limit resource consumption per transaction. The most commonly tested governor limits include:

Limit	Value
SOQL queries per synchronous transaction	100
DML statements per transaction	150
Heap size (synchronous)	6 MB
CPU time (synchronous)	10,000 milliseconds
Callouts per transaction	100
Future methods per transaction	50

Salesforce development lifecycle: Understand the distinction between Developer Sandbox, Partial Copy Sandbox, Full Sandbox, and Production org purposes and limitations.

Declarative vs. programmatic development: The exam tests judgment about when to use point-and-click tools (Flow Builder, validation rules, formula fields) versus Apex code. The general PMI-equivalent principle in Salesforce: use declarative when possible, code when necessary.

---

Data Modeling and Management (13%)

Effective Salesforce development requires deep understanding of the data model layer -- how objects relate, how data flows, and how platform rules affect data operations.

Objects and Relationships

Standard Objects: Salesforce-provided objects like Account, Contact, Opportunity, Lead, and Case. Developers must understand their field types, default behaviors, and how they relate to each other.

Custom Objects: Developer-created objects for business-specific data. Custom object API names end in __c (e.g., Invoice__c).

Relationship Types:

• Lookup Relationship: Loose coupling between objects; child record can exist without parent
• Master-Detail Relationship: Strong coupling; child record is deleted when parent is deleted; child inherits sharing rules from parent
• Many-to-Many: Implemented via a junction object with two master-detail relationships
• Hierarchical Relationship: Self-referential lookup specific to User object

External IDs and Upsert Operations: The upsert DML statement uses an external ID field to match existing records for update or insert new ones if no match exists. Critical for data integration patterns.

SOQL and SOSL

SOQL (Salesforce Object Query Language): The primary query language for Salesforce data. Developers must know:

• Basic SELECT syntax: SELECT Id, Name FROM Account WHERE Industry = 'Technology'
• Relationship queries: Parent-to-child (subquery) and child-to-parent
• LIMIT, ORDER BY, GROUP BY
• Aggregate functions: COUNT, SUM, AVG, MIN, MAX
• Semi-joins and anti-joins

SOSL (Salesforce Object Search Language): Full-text search across multiple objects simultaneously. Use SOSL when you need to search multiple objects or text fields across the platform.

FIND 'Acme' IN ALL FIELDS RETURNING Account(Name, Industry), Contact(FirstName, LastName)

"Understanding when to use SOQL versus SOSL is a frequent exam question. Use SOQL when you know which object to query. Use SOSL when you need to search across multiple objects or when you have a text search requirement." -- Trailhead, Salesforce Developer Documentation

---

Process Automation and Logic (13%)

This domain tests declarative automation tools as they relate to developer workflows and the boundaries between configuration and code.

Flow Builder for Developers

Developers must understand Flow Builder not to configure flows (that is an admin skill) but to recognize when a flow is the appropriate solution and how to invoke flows from Apex or LWC.

Flow types and when to use each:

• Screen Flows: User-facing flows invoked from a Lightning page, Quick Action, or community; can be launched from Flow.Interview in Apex
• Record-Triggered Flows: Triggered by record creation, update, or deletion; replaces most Apex triggers for simple automation
• Scheduled Flows: Run on a schedule; replaces batch Apex for simpler time-based operations
• Autolaunched Flows: Called from Apex, Process Builder, or other flows

Invoking a Flow from Apex:

Map<String, Object> params = new Map<String, Object>();
params.put('recordId', someRecord.Id);
Flow.Interview myFlow = Flow.Interview.createInterview('My_Flow_Name', params);
myFlow.start();

Validation Rules and Formula Fields

These declarative tools are important developer knowledge because they reduce the need for Apex validation logic.

Validation Rules: Prevent record save when a formula condition evaluates to true. The formula uses the same functions as formula fields. Key exam insight: validation rules fire before Apex triggers on insert and update.

Formula Fields: Read-only fields whose values are calculated at query time. Unlike Apex, formula fields do not consume DML or SOQL limits.

---

User Interface (23%)

The User Interface domain is the second-largest and focuses heavily on Lightning Web Components, which represents the modern Salesforce UI framework.

Lightning Web Components (LWC)

Lightning Web Components is a JavaScript framework built on modern web standards. It uses HTML templates, JavaScript classes, and CSS. The exam tests component structure, component communication, and integration with Salesforce data.

LWC File Structure:

• componentName.html -- component template
• componentName.js -- component controller (JavaScript class)
• componentName.js-meta.xml -- configuration metadata
• componentName.css -- component styles (optional)

Core LWC Decorators:

• @api -- exposes a property or method as public API; parent components can pass data down
• @track -- marks a property as reactive (tracks nested changes in objects/arrays)
• @wire -- connects a property or function to a Salesforce data service (wire adapter)

Component Communication:

• Parent to child: Pass data using @api properties
• Child to parent: Dispatch custom events using new CustomEvent('eventname', { detail: data })
• Sibling components: Use a Lightning Message Service (LMS) channel or a common parent component

Wire Service for Salesforce Data:

import { LightningElement, wire } from 'lwc';
import { getRecord } from 'lightning/uiRecordApi';

export default class MyComponent extends LightningElement {
    @wire(getRecord, { recordId: '$recordId', fields: ['Account.Name'] })
    account;
}

Visualforce

While Visualforce is considered legacy technology, it remains on the PDI exam because many organizations still have Visualforce pages in production.

Key Visualforce concepts:

• <apex:page> controller attribute: specify a standard controller or custom controller class
• <apex:form> and <apex:commandButton>: form submission pattern
• <apex:pageBlockTable> and <apex:repeat>: list rendering
• Extensions vs. custom controllers
• View state limits (135KB maximum for Visualforce view state)

"Lightning Web Components is the future of Salesforce UI development, but Visualforce is still relevant in exam and real-world contexts. Study both, but prioritize LWC. Expect 60-70% of UI questions to focus on LWC." -- David Liu, Salesforce Developer and author of Salesforce Developer Certification Study Guide

---

Apex Programming (24%)

Apex is the largest exam domain and the one where candidates with limited programming experience struggle most. Apex is a strongly typed, object-oriented language that runs on Salesforce servers.

Core Apex Syntax and Data Types

// Variables
String name = 'Acme';
Integer quantity = 100;
Decimal price = 49.99;
Boolean isActive = true;
Date today = Date.today();
Id accountId = '0015g00000X1ABCDE2';

// Collections
List<String> names = new List<String>{'Alice', 'Bob', 'Charlie'};
Set<Id> accountIds = new Set<Id>();
Map<Id, Account> accountMap = new Map<Id, Account>();

DML Operations

The five DML operations and their behaviors:

Operation	Purpose	Returns
insert	Create new records	Database.SaveResult[]
update	Modify existing records	Database.SaveResult[]
upsert	Insert or update based on ID/external ID	Database.UpsertResult[]
delete	Move records to recycle bin	Database.DeleteResult[]
undelete	Restore from recycle bin	Database.UndeleteResult[]

Bulkification is the most critical Apex development pattern. All DML and SOQL must be moved outside of loops to avoid hitting governor limits.

Wrong (triggers governor limits):

for (Account acc : trigger.new) {
    Contact c = [SELECT Id FROM Contact WHERE AccountId = :acc.Id]; // SOQL in loop
    update c;
}

Correct (bulkified):

Set<Id> accountIds = new Set<Id>();
for (Account acc : trigger.new) {
    accountIds.add(acc.Id);
}
List<Contact> contacts = [SELECT Id FROM Contact WHERE AccountId IN :accountIds]; // One SOQL
update contacts; // One DML

Apex Triggers

Triggers execute before or after DML operations on Salesforce records.

Trigger contexts:

• before insert, before update, before delete
• after insert, after update, after delete, after undelete

Best Practice -- One trigger per object with a handler class:

trigger AccountTrigger on Account (before insert, before update, after insert) {
    AccountTriggerHandler.handleTrigger(Trigger.new, Trigger.old, Trigger.operationType);
}

Trigger context variables: Trigger.new, Trigger.old, Trigger.newMap, Trigger.oldMap, Trigger.isInsert, Trigger.isUpdate, Trigger.isBefore, Trigger.isAfter

Asynchronous Apex

When operations exceed synchronous limits or require long-running execution, use asynchronous Apex:

• @future methods: Run in a separate thread; cannot accept sObject parameters; limited to 50 per transaction
• Batch Apex: Process large data sets in chunks (up to 50 million records); implement Database.Batchable interface
• Scheduled Apex: Run on a schedule; implement Schedulable interface
• Queueable Apex: Chained asynchronous jobs with object parameter support; preferred over @future for new development

---

Testing, Debugging, and Deployment (20%)

Salesforce requires 75% code coverage for Apex to deploy to production. The exam tests whether candidates understand the testing framework, not just the coverage percentage.

Apex Testing Framework

Test class structure:

@isTest
private class AccountTriggerHandlerTest {
    @TestSetup
    static void makeData() {
        // Create test data once for all test methods
        Account acc = new Account(Name = 'Test Account');
        insert acc;
    }
    
    @isTest
    static void testAccountInsert() {
        Account acc = [SELECT Id, Name FROM Account WHERE Name = 'Test Account' LIMIT 1];
        
        Test.startTest();
        // Perform actions to test
        Test.stopTest();
        
        // Assertions
        System.assertEquals('Test Account', acc.Name, 'Account name should match');
    }
}

Key testing best practices:

• Use @TestSetup for shared test data rather than creating data in each method
• Use Test.startTest() and Test.stopTest() to reset governor limits within a test
• Test both positive (expected behavior) and negative (error handling) scenarios
• Never use SeeAllData=true unless absolutely required for Standard Price Book tests

Deployment Methods

Method	Use Case
Change Sets	Simple deployments between related orgs (sandbox to production)
Salesforce CLI (sf command)	CI/CD pipelines, metadata API deployments
Packages (Unlocked, Managed)	ISV distribution, modular development
Ant Migration Tool	Legacy deployments; largely replaced by Salesforce CLI

---

Frequently Asked Questions

Do I need the Salesforce Administrator certification before Platform Developer I? The Administrator certification is not an official prerequisite for PDI, but most successful PDI candidates have administrator-level knowledge of the Salesforce platform. Salesforce recommends 6+ months of development experience. Candidates who lack admin knowledge should complete at least the admin Trailhead trail before beginning PDI preparation.

How different is the PDI exam from the Platform Developer II exam? Platform Developer I tests foundational Apex, LWC, and Salesforce development concepts. Platform Developer II tests advanced patterns including integration architecture, large-scale data design, performance optimization, and complex Apex patterns. PDII also includes a superbadge practical assessment in addition to the multiple-choice exam. Most candidates take PDI first and gain 12-18 months of development experience before attempting PDII.

What percentage of the PDI exam is Apex vs. LWC? Apex accounts for 24% and the User Interface domain (primarily LWC) accounts for 23% of the exam, together representing nearly half the total questions. Candidates who are strong in Apex but weak in LWC (or vice versa) frequently fail because the combined weight of these two areas is so significant.

References

1. Salesforce. "Salesforce Certified Platform Developer I Exam Guide." Trailhead.salesforce.com, 2024.
2. Salesforce. "Apex Developer Guide." developer.salesforce.com, 2024.
3. Salesforce. "Lightning Web Components Developer Guide." developer.salesforce.com, 2024.
4. Liu, David. Salesforce Developer Certification Study Guide. Apress, 2022.
5. Salesforce Trailhead. "Platform Developer I Certification Prep" Superbadge Trail. trailhead.salesforce.com, 2024.
6. Salesforce. "Apex Testing." Trailhead Module. trailhead.salesforce.com, 2024.
7. Salesforce. "Governor Limits and Execution Governors." Apex Developer Guide. developer.salesforce.com, 2024.