Salesforce · PDI
Salesforce Certified Platform Developer I (PDI) Practice Test
Validates the ability to design, develop, and deploy custom applications on the Salesforce Lightning Platform using Apex, Visualforce, and Lightning Components. Demonstrates proficiency in process automation, user interface development, testing, and deployment.
Exam Details
Questions
600
Duration
105 minutes
Passing Score
68%
Difficulty
AssociateLast Updated
Jun 2026
Topics Covered
Process Automation & LogicUser Interface (Visualforce & LWC)Developer FundamentalsTesting & DebuggingDeploymentData Modeling & ManagementSecurity & Access
Salesforce Certified Platform Developer I (PDI) Practice Exam Preparation
Use this PDI practice exam to prepare for Salesforce Certified Platform Developer I (PDI) with realistic questions, detailed explanations, and focused study modes. The practice bank includes 600 questions for Salesforce PDI, so you can review the exam steadily instead of relying on one long cram session.
As you practice, pay extra attention to recurring topics such as Process Automation & Logic, User Interface (Visualforce & LWC), Developer Fundamentals, Testing & Debugging, and Deployment. Start with short sessions to identify weak areas, then move into timed quizzes once your accuracy is consistent.
The explanations are especially useful when you want to connect exam wording to the responsibilities and scenarios described in the official certification guidance. Use the free preview first, then unlock the full question bank when you are ready to build a complete study routine.
Exam Domain Breakdown
Developer Fundamentals23%
Process Automation & Logic30%
User Interface25%
Testing, Debugging, and Deployment22%
Exam Overview
The Salesforce Certified Platform Developer I (PDI) credential validates a developer's ability to design, build, test, and deploy custom applications on the Salesforce Lightning Platform. It covers both declarative and programmatic development techniques, requiring demonstrated proficiency in Apex (Salesforce's proprietary Java-like language), Visualforce, Lightning Web Components (LWC), and Aura Components. Candidates must understand the platform's multi-tenant architecture, the Model-View-Controller (MVC) framework as applied to Salesforce, and governor limits that constrain resource usage in shared environments.
Beyond code, the exam tests knowledge of data modeling with standard and custom objects, SOQL and SOSL query languages, DML operations, process automation tools (such as Flow and approval processes), platform security (sharing rules, profiles, permission sets), and the full deployment lifecycle using Salesforce DX, Change Sets, and the Salesforce CLI. The PDI is considered the foundational developer credential in the Salesforce ecosystem and is a prerequisite stepping stone toward the Platform Developer II and other advanced technical certifications.
Who Should Take This Exam
This certification is designed for developers who have hands-on experience building custom applications on the Salesforce Lightning Platform—typically those with six months to two years of Salesforce development experience. Ideal candidates work in roles such as Salesforce Developer, Junior Developer, Technical Consultant, or Salesforce Administrator looking to move into a developer track. They should be comfortable writing Apex code, constructing Visualforce pages, and building Lightning Web Components in a professional or sandbox environment.
While developers are the primary audience, the broad scope of knowledge tested makes the certification valuable for Solution Architects, Technical Leads, and even experienced Administrators who want a deeper understanding of the platform's programmatic capabilities. No official prerequisite certification is required, though familiarity with Administrator and Platform App Builder concepts is strongly recommended.
Prerequisites
There are no mandatory prerequisite certifications for the PDI exam, but Salesforce recommends that candidates possess the equivalent knowledge covered by the Salesforce Certified Administrator and Salesforce Certified Platform App Builder exams before attempting this credential. A solid grasp of declarative automation tools—Flows, validation rules, formula fields, and approval processes—is essential, as the exam tests when to use declarative versus programmatic solutions.
On the technical side, candidates should have practical experience writing Apex classes, triggers, and unit tests; constructing SOQL and SOSL queries; and working with the Lightning Component framework. Familiarity with object-oriented programming principles (inheritance, polymorphism, collections) and relational database concepts (entity relationships, normalization) is assumed. Salesforce recommends completing the Trailhead Cert Prep: Platform Developer I trail, which consists of four modules covering Fundamentals, Database Modeling, Process Automation, and User Interfaces.
Exam Format
The Salesforce Certified Platform Developer I exam consists of 60 scored multiple-choice and multiple-select questions. Candidates are given 105 minutes to complete the exam. The passing score is 68%, meaning a candidate must correctly answer approximately 41 of the 60 questions. The exam is delivered through Pearson VUE and can be taken either at an authorized testing center or via online proctoring. The registration fee is $200 USD, with a retake fee of $100 USD.
Multiple-select questions require candidates to choose all correct answers from a list (typically two or three correct options out of five), and partial credit is not awarded—all correct choices must be selected. The exam is currently offered in English. Salesforce periodically updates the exam to reflect platform releases; candidates should download the current exam guide PDF from the official Salesforce developer certification site before studying to confirm the latest objective weights.
Skills Measured
- 1.Developer Fundamentals (23%): Understanding of multi-tenant architecture and its implications (governor limits, bulkification), the MVC pattern on Salesforce, use of standard and custom metadata types, Lightning Component framework architecture, and when to use declarative versus programmatic approaches to solve business problems.
- 2.Process Automation & Logic (30%): Writing Apex classes, triggers, and anonymous code; using collections (Lists, Sets, Maps); applying SOQL and SOSL for data retrieval; executing DML operations; understanding order of execution and trigger context variables; implementing platform events; identifying and avoiding common security vulnerabilities (SOQL injection, XSS); and building automation with Flow, approval processes, and Apex.
- 3.User Interface (25%): Developing Visualforce pages and controllers (standard, custom, and extension controllers); building Lightning Web Components and Aura Components; using the Lightning Data Service; applying component communication patterns (parent-child, event-based); and knowing when each UI framework is appropriate.
- 4.Testing, Debugging, and Deployment (22%): Writing Apex unit tests with meaningful assertions and achieving required code coverage (75% minimum for deployment); using the Developer Console, debug logs, and checkpoints for troubleshooting; deploying metadata using Change Sets, Salesforce DX, and the Salesforce CLI; and understanding sandbox types and their role in the development lifecycle.
Study Tips
- Download the official Salesforce Certified Platform Developer I Exam Guide PDF from developer.salesforce.com and use the domain weightings to prioritize study time—Process Automation & Logic (30%) and User Interface (25%) together account for more than half the exam.
- Complete all four Trailhead Cert Prep: Platform Developer I modules on Trailhead (Fundamentals & Database Modeling, Process Automation & Logic, User Interfaces, and Testing & Debugging), as they include scenario-based flashcards and direct links to the Apex Developer Guide sections most likely to be tested.
- Practice writing Apex in a Developer Edition org or Trailhead Playground daily—focus on bulk-safe triggers, SOQL inside loops (a common trap question), and writing test classes with System.assert() statements. The exam heavily tests recognition of code errors and governor limit violations.
- Study the order of execution for Salesforce record saves thoroughly (before triggers, validation rules, after triggers, workflow, etc.), as multiple questions test whether candidates can predict what happens when multiple automation tools interact on the same record.
- Use the Apex Developer Guide and Lightning Web Components Developer Guide on developer.salesforce.com as primary references. For LWC specifically, know the difference between @track, @api, and @wire decorators, and understand how components communicate via custom events versus public properties.
- Take at least two full-length timed practice exams from Focus on Force or Trailhead Superbadges before the real exam. Review every incorrect answer against the official documentation to understand the 'why,' not just the 'what.'
- Join the Trailblazer Community's Platform Developer I study group to ask scenario-based questions and access community-curated study notes. Many candidates report that community discussion of tricky governor limit and trigger context scenarios directly mirrors real exam questions.
Career Benefits
Earning the Salesforce Certified Platform Developer I credential significantly increases employability in the Salesforce ecosystem, which remains one of the fastest-growing segments of enterprise software. Certified Salesforce Developers in the United States earn average base salaries ranging from approximately $96,000 to $120,000 annually, with senior developers and architects commanding $145,000 or more. The certification provides a verifiable, vendor-recognized signal of competency that distinguishes candidates in a competitive job market and is frequently listed as a requirement or strong preference in Salesforce Developer, Technical Consultant, and Solution Architect job postings.
The PDI also serves as the gateway to more advanced Salesforce technical credentials, including the Salesforce Certified Platform Developer II, JavaScript Developer I, and Salesforce Architect certifications. Organizations that are Salesforce partners track certified headcount to maintain tier status, creating institutional demand for certified professionals. The broader Salesforce services market is projected to exceed $24 billion by 2029, ensuring sustained demand for skilled, credentialed platform developers across industries including financial services, healthcare, retail, and technology.
Sample Questions
5 sample questions with answers and explanations. Start a practice session to test yourself across all 600 questions.
Preview — answers shown1. A developer at AW Computing writes a test class that includes a @TestSetup method. The @TestSetup method inserts a single Account record with the Name field set to 'Original Corp'. The first test method queries the Account, updates the Name field to 'Modified Corp', and successfully commits the change with a DML update. When the second test method queries the same Account record, what value does the Name field contain? (Select one!)
A'Modified Corp' because all test methods in the class share a common database state
BA DmlException is thrown because the Account was already modified by the previous test method
C'Original Corp' because each test method receives an isolated and unchanged copy of the @TestSetup data
DAn empty string because the Account record state is cleared between test method executions
Explanation
The @TestSetup annotation guarantees that each test method in the class begins execution with an isolated, unchanged copy of the data created by the setup method. When the first test method modifies the Account name and commits the change, that modification is automatically rolled back before the second test method begins. This isolation ensures that the order in which test methods execute does not affect their outcome and that no test method can corrupt the starting state of another. The @TestSetup method runs only once before all test methods in the class, but the database state is independently reset for each individual test method. This design makes @TestSetup ideal for creating shared test fixtures that remain consistent and predictable regardless of which test runs first or how many tests modify the shared records.
2. A developer at AW Computing writes an after-insert trigger on the Account object. The trigger must create a PermissionSetAssignment record to grant a specific permission set to the new Account owner. During unit testing, the developer encounters a System.DmlException: Mixed DML Operation error. What should the developer do to resolve this error? (Select one!)
AWrap both DML operations inside a single try-catch block to prevent the exception from propagating
BChange the trigger from after-insert to before-insert so that both DML operations execute in the same pre-save phase
CReplace the insert DML statement with Database.insert() using allOrNone set to false to suppress the error
DMove the PermissionSetAssignment creation logic into a @future method so that it runs in a separate transaction
Explanation
Salesforce prohibits performing DML on both setup objects (User, Group, PermissionSet, PermissionSetAssignment) and non-setup objects within the same transaction, which causes the Mixed DML Operation error. Moving the PermissionSetAssignment DML into a @future method executes it in an entirely separate transaction, fully resolving the conflict. Changing the trigger from after-insert to before-insert still results in both DML operations occurring in the same transaction, so the Mixed DML error persists. Wrapping the operations in a try-catch block does not resolve the issue because the platform enforces the Mixed DML restriction at the transaction boundary before the exception can be caught at the code level. Using Database.insert() with allOrNone set to false changes partial-success behavior for individual records but does not bypass the Mixed DML transaction restriction.
3. A developer at Cloud Kicks is designing a data model to relate a custom Job__c object to an Account. The business has two requirements: Job__c records must always have a parent Account and cannot be saved without one, and the Account record must automatically display a COUNT of all related open Job__c records without writing any Apex. Which two statements describe the relationship type that satisfies both requirements? (Select two!)
Multiple correct answersAUse a Lookup relationship because the required parent field and the COUNT aggregate can both be configured on Lookup relationships
BUse a Master-Detail relationship because the child record requires a mandatory parent, which is enforced by default on Master-Detail
CRoll-up summary fields including COUNT can only be configured natively on Master-Detail relationships, not on Lookup relationships
DLookup relationships support roll-up summary fields when the lookup field is marked as required on the child object
EMaster-Detail relationships always allow child records to be reparented to a different Account without any additional configuration
Explanation
Master-Detail relationships enforce a mandatory parent by default — the relationship field on the child is required, and deleting the parent cascades deletion to all children. This satisfies the requirement that Job__c cannot be saved without a parent Account. Roll-up summary fields (COUNT, SUM, MIN, MAX) are only natively available on Master-Detail relationships; Lookup relationships do not support this feature without custom Apex, a Flow, or a third-party tool such as DLRS. Lookup relationships allow the child to exist without a parent and do not support native roll-up summaries regardless of whether the lookup field is required. Master-Detail relationships do not allow reparenting by default; the Allow Reparenting option must be explicitly enabled in the field configuration after creation.
4. A developer at Cloud Kicks needs to automate a business rule: whenever an Order__c record is created or updated, the Total_Price__c field must be recalculated by multiplying Quantity__c by Unit_Price__c, both of which are fields on the same Order__c record. The developer must implement this using a Record-Triggered Flow and minimize the number of DML statements consumed during the process. Which configuration should the developer choose? (Select one!)
AAn After-Save Record-Triggered Flow that publishes a platform event consumed by a separate flow that updates Total_Price__c
BA Before-Save Record-Triggered Flow that uses an Assignment element to set Total_Price__c on the triggering record
CA Scheduled Record-Triggered Flow with a Scheduled Path configured to run zero hours after the trigger event
DAn After-Save Record-Triggered Flow that uses an Update Records element to write Total_Price__c back to the triggering Order__c record
Explanation
A Before-Save Record-Triggered Flow is the most efficient solution for modifying fields on the triggering record itself. Before-save flows execute before the record is committed to the database and can update fields on the triggering record using Assignment elements without consuming any DML statements, because the field update is bundled into the same save operation. An After-Save Record-Triggered Flow using an Update Records element would also update the field correctly, but it runs after the record has already been saved, so writing Total_Price__c back consumes one additional DML statement. Scheduled paths are designed for time-delayed actions and cannot replace the immediate synchronous execution needed here. Using a platform event to chain a second flow introduces significant overhead, latency, and additional DML for what is a simple same-record field calculation that before-save flows handle natively.
5. A developer at DreamHouse Realty is building a Lightning Web Component that integrates a third-party charting library. The library requires access to a canvas HTML element defined in the component's template. The developer must guarantee that the DOM element is available before calling the library's initialization method. Which lifecycle hook is the correct place to initialize the chart library? (Select one!)
ArenderedCallback()
BconnectedCallback()
Cconstructor()
DdisconnectedCallback()
Explanation
renderedCallback() fires after the component's template has been fully rendered and all DOM elements are available for interaction. This makes it the appropriate hook for initializing libraries that require direct access to DOM elements such as a canvas. constructor() fires before the component is inserted into the DOM, so template elements do not yet exist and cannot be accessed. connectedCallback() fires when the component is connected to the DOM but before rendering completes, which means the template's child elements may not be present at that point. disconnectedCallback() fires when the component is removed from the DOM and is used for cleanup, not initialization.
$7.99
One-time access to this exam
Full access to all 600 questions
Or $15/mo for all 253 exams
Detailed explanations
Free preview stays available