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 Cloud Kicks needs to make an asynchronous HTTP callout to an external pricing API from an Apex trigger. They decide to implement a @future method to handle the callout. Which two characteristics of @future methods must the developer consider when designing this solution? (Select two!)
Multiple correct answersAThe @future method must be declared as static and must return void
BThe @future method can accept Account sObject parameters to pass record data directly
CThe @future annotation must include (callout=true) to enable outbound HTTP callouts
DA @future method can invoke another @future method to chain asynchronous processing steps
EThe @future method returns a job ID that can be used to monitor its execution in Apex Jobs
Explanation
Future methods have two key design constraints that apply directly to this scenario. First, every @future method must be declared as static and must return void — no other return types or instance-level declarations are permitted. Second, to perform outbound HTTP callouts, the annotation must explicitly include (callout=true), written as @future(callout=true); omitting this flag causes a CalloutException at runtime. Future methods cannot accept sObject parameters — only primitives and collections of primitives are allowed, so the developer must pass Account IDs as Strings or a List of Id values rather than full Account records. One @future method cannot invoke another @future method within the same transaction, which would throw an AsyncException. Unlike Queueable Apex, future methods do not return a job ID and provide no built-in mechanism for execution monitoring.
2. A developer at DreamHouse Realty is importing 500 Property__c records from an external system. Some records have validation errors and must be skipped, but all valid records should be saved in the same operation. The developer uses the following DML operation: Database.insert(propertyList, false). What is the behavior of this operation when some records have errors? (Select one!)
AThe Database.insert method automatically corrects validation errors using default field values and retries each failed record before returning
BAll 500 records are rejected because partial success is not supported when validation rules are present on the object
CA DmlException is thrown when the first invalid record is encountered, preventing all subsequent records from being inserted regardless of their validity
DValid records are inserted successfully and a list of Database.SaveResult objects is returned, allowing the developer to inspect the success or failure of each individual record
Explanation
Passing false as the allOrNone parameter to Database.insert enables partial success mode, where valid records are committed to the database and invalid records are skipped without throwing an exception. The method returns a List<Database.SaveResult> with one SaveResult per input record in the same order as the input list. Each SaveResult contains an isSuccess() method indicating whether the record was saved and a getErrors() method returning a list of Database.Error objects for failed records. This allows the developer to iterate the results and handle failures individually. Standard DML statements such as insert without the Database class always throw a DmlException on the first error and roll back the entire operation. Database methods with allOrNone=true behave identically to DML statements by failing on any error. The Database.insert method never automatically corrects errors or retries records.
3. A developer at DreamHouse Realty writes an after insert trigger on the Property__c object. After a Property__c record is inserted, the trigger attempts to insert a GroupMember record to automatically add the property owner to an internal group. During testing, the trigger throws an unexpected runtime exception. Which statement correctly identifies the cause and the recommended production-safe resolution? (Select one!)
APerforming DML on a setup object such as GroupMember in the same transaction as DML on a non-setup object such as Property__c is prohibited by the platform; the GroupMember insert should be moved into an @future method to execute in a separate transaction
BThe trigger context is incorrect; converting the trigger from after insert to before insert allows setup and non-setup DML to coexist in the same transaction
CGroupMember records can only be inserted via the Salesforce Setup UI; Apex triggers are not permitted to perform DML on setup objects under any circumstances
DThe developer must wrap the GroupMember insert in a System.runAs() block inside the trigger body to elevate permissions and bypass the mixed DML restriction in production
Explanation
Salesforce enforces a mixed DML restriction that prohibits a single transaction from performing DML on both setup objects (User, Group, GroupMember, PermissionSet, PermissionSetAssignment) and non-setup objects simultaneously. This restriction applies regardless of trigger context (before or after) and throws a runtime exception when violated. The recommended production-safe workaround is to move the setup object DML into an @future method, which runs asynchronously in a completely separate transaction after the current one completes. System.runAs() can bypass this restriction only inside test methods; it is not a valid workaround in production Apex trigger code. Trigger context type has no effect on the mixed DML restriction. Apex triggers are fully capable of performing DML on setup objects as long as no non-setup DML occurs in the same transaction.
4. A developer at Ursa Major Solar builds an LWC component that maintains a list of product items in a JavaScript property defined as items = [{ id: 1, name: 'Widget A' }]. The template uses for:each to iterate over the items array. When the developer calls this.items.push({ id: 2, name: 'Widget B' }) inside a button click handler, the template does not re-render to show the new item. Which two approaches will fix the re-rendering issue? (Select two!)
Multiple correct answersAAdd the @api decorator to the items property to make it publicly reactive to parent component changes.
BAdd the @track decorator to the items property to enable tracking of mutations within the array.
CReplace the push() call with array reassignment: this.items = [...this.items, { id: 2, name: 'Widget B' }]
DDispatch a CustomEvent named refresh after the push() call to notify the framework of the change.
EMove the items property initialization into the connectedCallback() lifecycle hook.
Explanation
Two valid approaches exist to fix this re-rendering issue. Adding @track to the items property instructs the LWC framework to observe deep mutations within the array, including elements added via push(), and triggers re-rendering when those mutations occur. Alternatively, replacing push() with array reassignment using the spread operator creates a new array reference, which the framework detects as a changed property value and triggers re-rendering automatically. The @api decorator exposes a property to parent components for data binding but does not enable deep mutation tracking on array elements within the component itself. Dispatching a CustomEvent only communicates state changes to parent components and does not cause the originating component to re-render. Moving items initialization to connectedCallback() changes when the array is created but does not address how mutations to it trigger reactivity.
5. A developer at Ursa Major Solar builds a Lightning Web Component with a JavaScript property filterCriteria initialized as an empty object. The template binds to filterCriteria.minAmount. When the user clicks a button, the handler mutates the property directly with this.filterCriteria.minAmount = newValue, but the template does not re-render. Which two changes will resolve the issue? (Select two!)
Multiple correct answersAAdd the @api decorator to filterCriteria to expose it as a public reactive property
BAdd the @track decorator to filterCriteria so the framework observes mutations within the object
CReassign filterCriteria to a new object reference that includes the updated minAmount value
DCall this.template.querySelector() after the mutation to manually trigger a re-render cycle
EAdd the @wire decorator to filterCriteria and connect it to a Salesforce data provider
Explanation
Two independent approaches resolve the issue. Adding the @track decorator to filterCriteria instructs the LWC framework to perform deep observation of the object, detecting mutations to nested properties like minAmount and triggering a re-render when they change. Reassigning filterCriteria to a new object reference such as this.filterCriteria = {...this.filterCriteria, minAmount: newValue} also works because LWC natively detects reassignment of top-level properties by reference, causing the framework to recognize a change and re-render. Without either change, directly mutating a nested property does not alter the top-level reference, so the framework sees no change and skips re-rendering. Adding @api exposes the property to parent components for external data binding but does not enable deep mutation tracking for internal state. There is no manual re-render trigger API in LWC. The @wire decorator connects a property to a Salesforce data provider and is unrelated to internal state reactivity.
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