Salesforce · PDI
Salesforce Certified Platform Developer I (PDI) Practice Tests
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
Practice Questions
600
≈ 10 practice exams
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. The full bank has 600 questions, enough for 10 full-length practice exams.
Preview — answers shown1. A developer at Universal Containers is designing a data model where a Contact can be associated with many Projects, and a Project can have many Contacts. The developer also needs the Project record to display a count of how many Contacts are currently associated with it. Which two statements are true about implementing this requirement? (Select two!)
Multiple correct answersAA junction object with two Master-Detail relationships implements the many-to-many association, and a native roll-up summary COUNT field can be created on the Project object
BA junction object with two Lookup relationships implements the many-to-many association, and a native roll-up summary COUNT field can still be created on the Project object
CThe junction object's record-level security is inherited from its primary parent, which is the master object from the first Master-Detail relationship created on the junction object
DRoll-up summary fields are natively supported on both Lookup and Master-Detail relationships without requiring additional configuration
EA junction object is limited to exactly one Master-Detail relationship and must use a Lookup relationship for the second parent
Explanation
Junction objects use two Master-Detail relationships to implement many-to-many data modeling. When a Master-Detail relationship exists, native roll-up summary fields including COUNT, SUM, MIN, and MAX can be created on the master parent object, allowing the Project record to display a count of associated junction records. The junction object's sharing and security are controlled by its primary parent, which is determined by the first Master-Detail relationship created on the junction object — this is a critical platform behavior when designing record access models. Lookup relationships do not support native roll-up summary fields; achieving similar aggregation over a Lookup relationship requires Apex triggers, Record-Triggered Flows, or third-party tools. A junction object supports up to two Master-Detail relationships plus additional Lookup relationships, not just one Master-Detail.
2. A developer at Universal Containers has written an Apex trigger on the Account object that handles before delete, after delete, before update, and after update events. A system administrator uses the Salesforce UI to merge three duplicate Account records into one master record. Which two trigger events fire on the Account object as a direct result of this merge operation? (Select two!)
Multiple correct answersABefore insert and after insert on the winning master record
BBefore delete and after delete on the two losing records
CBefore update and after update on the winning master record
DBefore undelete and after undelete on all three records
EOnly after delete on the losing records because before delete is skipped during a merge
Explanation
A merge operation fires two distinct sets of trigger events. Delete triggers — both before delete and after delete — fire on the losing records that are being merged away. Update triggers — both before update and after update — fire on the winning master record because its fields are updated with the consolidated data from the merged records. The merge operation does not fire insert triggers on the master record because it already exists. There is no before undelete or after undelete event triggered by a merge. Before delete is not skipped during a merge; it fires exactly as it does during a normal delete operation on the losing records.
3. A developer at AW Computing is optimizing a Batch Apex class that processes hundreds of thousands of records. The developer is comparing synchronous versus asynchronous governor limits to understand which restrictions relax in an async context. Which two governor limits are more generous in an asynchronous execution context compared to a synchronous context? (Select two!)
Multiple correct answersADML statements per transaction, which remains at 150 in both synchronous and asynchronous contexts
BSOQL queries per transaction, which increases from 100 in synchronous to 200 in asynchronous contexts
CDML rows processed per transaction, which remains at 10,000 in both synchronous and asynchronous contexts
DHeap size per transaction, which increases from 6 MB in synchronous to 12 MB in asynchronous contexts
EMaximum callouts per transaction, which remains at 100 in both synchronous and asynchronous contexts
Explanation
In asynchronous Apex contexts such as Batch Apex, Queueable, Scheduled Apex, and future methods, two limits are significantly more generous than in synchronous contexts. SOQL queries double from 100 to 200 per transaction, enabling more complex data retrieval in each execute() invocation. Heap size doubles from 6 MB to 12 MB, allowing larger in-memory collections for bulk processing. DML statements remain at 150 in both contexts, meaning the DML statement limit does not increase in async code. DML rows processed also remain at 10,000 in both contexts. Callout limits remain at 100 in both contexts. Developers should also note that CPU time increases significantly in async contexts, from 10,000 ms to 60,000 ms, providing another important benefit for computation-heavy batch operations.
4. A developer at AW Computing is investigating a synchronous Apex transaction that consistently hits governor limit exceptions due to heavy calculations on large data sets. The team decides to refactor the solution to run asynchronously. Which three governor limits increase when Apex code executes in an asynchronous context compared to a synchronous context? (Select three!)
Multiple correct answersACPU time limit (increases from 10,000 ms to 60,000 ms)
BSOQL query limit (increases from 100 to 200 queries per transaction)
CDML statement limit (increases from 150 to 300 statements per transaction)
DHeap size limit (increases from 6 MB to 12 MB)
EMaximum @future method calls allowed per transaction (increases from 50 to 100)
FMaximum number of records retrieved by a single SOQL query (increases from 50,000 to 100,000)
Explanation
Three governor limits increase when Apex runs asynchronously: CPU time increases from 10,000 ms to 60,000 ms enabling long-running complex calculations; the SOQL query limit increases from 100 to 200 queries per transaction allowing more data retrieval; and heap size increases from 6 MB to 12 MB supporting larger in-memory data structures. Critically, the DML statement limit does NOT increase when moving to an asynchronous context — it remains 150 for both synchronous and asynchronous execution. This is a frequently tested distinction because developers often assume all limits increase in async. The maximum @future method calls per transaction stays at 50 regardless of execution context, and the single-query record retrieval limit of 50,000 rows does not change based on sync or async context.
5. At AW Computing, a developer builds a nested LWC structure where accountDashboard is the grandparent, metricsPanel is the child, and salesChart is the grandchild. When a user selects a date range in salesChart, the accountDashboard component must respond to the selection event. The developer does not want to add any event handling code to metricsPanel. Which CustomEvent configuration in salesChart should the developer use? (Select one!)
Athis.dispatchEvent(new CustomEvent('dateselected', { detail: this.selectedRange, cancelable: true }))
Bthis.dispatchEvent(new CustomEvent('dateselected', { detail: this.selectedRange, bubbles: true }))
Cthis.dispatchEvent(new CustomEvent('dateselected', { detail: this.selectedRange, composed: false }))
Dthis.dispatchEvent(new CustomEvent('dateselected', { detail: this.selectedRange }))
Explanation
Setting bubbles: true on a CustomEvent allows it to propagate upward through the component hierarchy, enabling accountDashboard (the grandparent) to listen for and handle the event without metricsPanel (the intermediate parent) requiring any event handling code. By default, custom events in LWC do not bubble, meaning only the immediate parent can receive them. Without bubbles: true, accountDashboard would never receive the dateselected event regardless of how its handler is registered. The cancelable property controls whether an event can be prevented with preventDefault and has no effect on propagation direction or reach. Setting composed: false (the default value) does not add bubbling behavior; it controls shadow DOM boundary crossing, which is separate from event bubbling.
More Salesforce Practice Exams
Salesforce Certified Advanced Administrator (CRT-211)
CRT-211 · 600 questions
Salesforce Certified Agentforce Specialist (AI-201)
AI-201 · 600 questions
Salesforce Certified Experience Cloud Consultant (EX-Con-101)
EX-Con-101 · 600 questions
Salesforce Certified Marketing Cloud Account Engagement Specialist (MC-201)
MC-201 · 600 questions
Salesforce Certified Marketing Cloud Email Specialist (MC-202)
MC-202 · 600 questions
Salesforce Certified Marketing Cloud Engagement Consultant (MCE-Con-201)
MCE-Con-201 · 600 questions
$17.99
One-time access to this exam
600 questions (10 practice exams' worth)
Unlimited timed exam simulations
Or $15/mo for all 253 exams
Detailed explanations
Free preview stays available