Salesforce Certified Platform Developer I Practice Exam

What the Salesforce Certified Platform Developer I exam covers

• Developer Fundamentals166 questions
• Process Automation and Logic232 questions
• User Interface180 questions
• Testing, Debugging, and Deployment160 questions

Free Salesforce Certified Platform Developer I practice test questions

A sample of 10 questions with answers and explanations. Sign up free to practice all 738.

1. Question 1Testing, Debugging, and Deployment

   A developer wants to quickly test a SOQL query and view the returned records in a grid, without writing any Apex code. Which Developer Console feature should be used?

   • ALog Inspector
   • BQuery EditorCorrect
   • CCheckpoints
   • DExecute Anonymous window
   ✓ Correct answer: B

   Query Editor is correct because it lets a developer type a SOQL or SOSL statement and see the matching records in a results grid immediately, with no Apex class, trigger, or deployment involved. The concept being tested is that Developer Console separates ad hoc data lookups from code execution, and Query Editor is purpose built for the former. Here the stem asks for a no-code way to view query results, which rules out any log-replay or code-execution tool. The other options are debugging or execution features that do not display query results directly. Takeaway: reach for Query Editor when the goal is viewing records, not running logic.

   Why the other options are wrong

   • ALog Inspector is for stepping through an existing debug log, not for running a query.
   • CCheckpoints capture variable state at a line of executing Apex; they do not run standalone queries.
   • DExecute Anonymous runs Apex code blocks; a raw SOQL statement is not valid Apex on its own.
2. Question 2Developer Fundamentals

   What is the main purpose of the 50,000-row SOQL query limit per transaction?

   • ATo cap the number of custom objects per org
   • BTo restrict daily API call volume
   • CTo enforce org-wide test coverage minimums
   • DTo prevent one transaction retrieving excess rowsCorrect
   ✓ Correct answer: D

   The correct answer is D: the 50,000-row limit stops one transaction from retrieving an excessive number of records through SOQL. The key concept, again, is protecting the shared multi-tenant platform: this row limit works alongside the 100-query cap to bound the total data volume a single transaction can pull back, keeping performance stable for every org sharing the same infrastructure. This question is testing recognition of a specific, named governor limit and its purpose, not object counts, API volume, or test coverage, all of which are governed separately. Remember: 100 queries controls how many SOQL statements run, while 50,000 rows controls how much data those statements can return in total.

   Why the other options are wrong

   • AThe number of custom objects allowed in an org is a separate metadata limit, unrelated to how many rows a query can return.
   • BDaily API call volume is tracked and capped independently of the per-transaction SOQL row retrieval limit.
   • CMinimum test coverage requirements for deployment are unrelated to how many rows a single transaction's SOQL queries can retrieve.
3. Question 3Developer Fundamentals

   In Apex, how does a developer reference a custom lookup relationship field to traverse from a child record to its parent, rather than referencing the raw foreign key Id?

   • AAppend __c to the relationship name
   • BAppend __r to the relationship nameCorrect
   • CAppend __pc to the field name
   • DUse the field label directly
   ✓ Correct answer: B

   Option B is correct because the __c field itself only stores the parent's Id, while Salesforce also generates a separate relationship name for that same field, always ending in __r, that is used specifically to walk to the parent record and read its fields, for example Account__r.Name. Appending __c again, inventing a __pc suffix, or using the field's label are all invalid, since Apex and SOQL only recognize the actual relationship name for this kind of traversal.

   Why the other options are wrong

   • A__c is the suffix on the field that stores the parent's Id value itself; it is not used for traversing to the parent's fields.
   • C__pc is not a valid Salesforce suffix or naming convention for any relationship or field.
   • DField labels are display text only; Apex and SOQL require the actual API name or relationship name, not a label.
4. Question 4Developer FundamentalsSelect all that apply

   Which two statements describe Data Loader's ability to relate imported child records to existing parents via external ID during a load? (Choose TWO)

   • ARequires the Data Import Wizard instead
   • BMaps the child field to the parent external IDCorrect
   • CRelates records without needing the parent IdCorrect
   • DOnly works if the parent has zero records
   • EBypasses all field-level security checks
   ✓ Correct answer: B, C

   B is correct because during CSV field mapping, Data Loader lets a developer point a relationship field at the parent object's external ID column instead of its 18-character Salesforce Id. C is correct because that external-ID-based mapping means the import file never needs to carry the actual parent Id at all; Data Loader resolves the matching parent record using the external ID value present on each row. Together these describe the standard technique for relating child records to existing parents during a migration. A is wrong because this capability is a Data Loader feature accessed through its field mapping dialog, not something requiring the Data Import Wizard instead. D is wrong because the parent object can already contain many existing records; matching by external ID still works correctly against however many parent rows exist. E is wrong because field-level security is still enforced for the running user during any data load.

   Why the other options are wrong

   • AThis external-ID-based relating capability is available directly in Data Loader's own field mapping dialog; it is not exclusive to the Data Import Wizard.
   • DMatching by external ID works regardless of how many existing parent records there are; the parent object is not required to be empty.
   • EField-level security is still enforced for the running user during any load operation; external ID mapping does not bypass those checks.
5. Question 5Process Automation and Logic

   Given a Set<String> named validStages populated in Apex, which SOQL clause correctly filters Opportunities to only those stages?

   • AWHERE StageName IN validStages
   • BWHERE StageName = :validStages
   • CWHERE StageName CONTAINS :validStages
   • DWHERE StageName IN :validStagesCorrect
   ✓ Correct answer: D

   WHERE StageName IN :validStages correctly combines the IN operator, which matches a field against any value in a collection, with the required colon prefix that binds the local Apex Set<String> variable into the inline SOQL query. Dropping the colon, as in option A, leaves validStages unbound, referencing an Apex variable inside inline SOQL always requires the colon, without it the query will not compile. Using a plain equals sign, as in option B, expects exactly one value to compare against, not a whole collection of possible matches. CONTAINS is not the correct operator for matching a field against a set of discrete values. Takeaway: filtering a field against a whole collection of possible values calls for IN plus a colon-bound Apex variable.

   Why the other options are wrong

   • AReferencing an Apex variable inside inline SOQL always requires the colon bind syntax; without it, the query will not compile.
   • BThe equals operator expects exactly one comparison value, not a whole collection of possible matching values.
   • CCONTAINS is not the correct SOQL operator for matching a field against a set of discrete values, IN is.
6. Question 6Process Automation and LogicSelect all that apply

   Which TWO statements about try/catch/finally in Apex are correct? (Choose TWO)

   • AA try block can exist without any catch block and without a finally block
   • BAt least one catch block is required whenever a try block is used
   • CIf an exception is thrown and no matching catch block exists, the finally block is skipped entirely
   • DThe finally block executes whether or not an exception was thrown, and whether or not it was caughtCorrect
   • EMultiple catch blocks can be chained to handle different exception types differentlyCorrect
   ✓ Correct answer: D, E

   The finally block executes no matter what happens in the preceding try and catch blocks, whether the try completed normally, threw an exception that was caught, or threw an exception that was never caught by any matching block and continues to propagate; this unconditional guarantee makes option D correct. Apex also supports chaining multiple catch blocks after a single try, each targeting a different exception type so that different failures can be handled differently, provided they are ordered from most specific subtype to the most general Exception type, which makes option E correct as well. A try block does not have to stand completely alone, however; it must be followed by at least one catch block, a finally block, or both, so a bare try with neither is not valid, ruling out option A. A catch block is not mandatory when a finally block is present, so a try paired only with finally is legal, meaning option B overstates the requirement. And finally still runs even when no catch block matches the thrown exception type, rather than being skipped, so the exception propagates only after finally has executed, ruling out option C.

   Why the other options are wrong

   • AA try block in Apex must be followed by at least one catch block, a finally block, or both; it cannot stand completely alone.
   • BA try block only needs a finally block to be valid; a catch block is not strictly required if finally is present.
   • Cfinally still executes even when an exception is not caught by any block; it runs before the exception continues propagating.
7. Question 7Process Automation and Logic

   A batch data load inserts 200 Account records in a single DML operation. How many separate times does the order of execution, from before triggers through after triggers, run for this one operation?

   • A200 times, once per individual Account record
   • BOnce, with all 200 records processed together as one batchCorrect
   • CTwice, since inserts are always processed in two passes
   • DOnce per unique field value present across the records
   ✓ Correct answer: B

   Option B is correct because Salesforce invokes the order of execution, before triggers through after triggers, once per DML statement, not once per record, so a single insert of 200 Accounts delivers all 200 records to Trigger.new in one pass. This is the same underlying reason bulkification matters: the trigger receives the full collection at once rather than being invoked 200 separate times, so any SOQL or DML in the trigger must handle the whole batch in a single pass to stay within governor limits. Options A, C, and D describe repetition counts, per record, twice, or per unique value, that do not reflect how the platform actually processes a batch DML statement. Remember: one DML statement means one trip through the order of execution, no matter how many records it contains.

   Why the other options are wrong

   • AThe order of execution is not repeated per record; it runs once for the batch as a whole.
   • CThere is no rule that inserts are always split into exactly two passes through the order of execution.
   • DThe order of execution has nothing to do with the number of distinct field values present in the data.
8. Question 8Testing, Debugging, and Deployment

   Is the 75 percent org-wide code coverage requirement enforced when deploying components into a sandbox rather than production?

   • AYes, sandboxes enforce a stricter 90 percent requirement
   • BYes, the identical 75 percent requirement applies to sandboxes
   • CNo, sandboxes instead require full 100 percent coverage
   • DNo, sandboxes do not enforce the 75 percent requirementCorrect
   ✓ Correct answer: D

   Option D is correct: the 75 percent org-wide coverage gate that blocks deployments applies specifically to production orgs, most sandbox types do not enforce this requirement, which is exactly what makes sandboxes convenient for iterative development before code has to clear the stricter production deployment gate. A is wrong because there is no stricter 90 percent enforcement applied specifically to sandbox deployments. B is wrong because sandboxes do not enforce the identical mandatory coverage gate that production deployments require. C is wrong because there is no 100 percent coverage requirement imposed on sandbox deployments either. Remember: coverage enforcement is a production-specific gate, sandboxes are comparatively permissive by design.

   Why the other options are wrong

   • AThere is no stricter 90 percent enforcement applied specifically to sandbox deployments.
   • BSandboxes do not enforce the same mandatory coverage gate that production deployments do.
   • CThere is no 100 percent coverage requirement imposed for sandbox deployments.
9. Question 9User Interface

   A component needs to call a third-party JavaScript library that manipulates the rendered DOM after the template is drawn. Which lifecycle hook is appropriate?

   • Aconstructor()
   • BdisconnectedCallback()
   • CrenderedCallback()Correct
   • DconnectedCallback() only
   ✓ Correct answer: C

   renderedCallback() runs after the template has actually rendered, so the real DOM elements a third-party JavaScript library needs to attach to or read already exist and can safely be manipulated; developers typically guard this setup with a one-time flag since renderedCallback can fire repeatedly. Option A is wrong because the constructor runs before any DOM exists for the component, so nothing can be manipulated there yet. Option B is wrong because disconnectedCallback fires on removal, not after rendering, the wrong time for this work. Option D is wrong because connectedCallback runs before the template has necessarily finished rendering, so DOM elements may not yet exist. Takeaway: DOM-dependent third-party setup belongs in renderedCallback, guarded against repeat firing.

   Why the other options are wrong

   • AThe constructor runs before any DOM exists for the component, so it cannot safely manipulate rendered output.
   • BdisconnectedCallback fires on removal, not after rendering, so it is the wrong time for this.
   • DconnectedCallback runs before the template has necessarily finished rendering, so DOM elements may not yet exist.
10. Question 10User Interface

    Which merge field returns the current logged-in user's first name on a Visualforce page?

    • A{!$User.FirstName}Correct
    • B{!User.FirstName}
    • C{!$Profile.FirstName}
    • D{!$CurrentUser.FirstName}
    ✓ Correct answer: A

    Global variables in Visualforce always carry a leading dollar sign inside the merge braces, and $User specifically exposes fields of the currently logged-in user, including FirstName. That dollar-sign prefix distinguishes a platform global variable from a reference to a record field or controller property, so this expression is unambiguous and requires no controller code to work. This fits any page that needs to reference the running user directly, without a User standard controller in play. Without the dollar sign, the expression would look for a User field on whatever the current controller's record is, which does not exist. $Profile exposes profile metadata, not the user's name, and $CurrentUser is not a real Visualforce global at all. The rule to remember: user-related globals live under $User.

    Why the other options are wrong

    • BWithout the dollar sign this would look for a User field on the current record's controller rather than the logged-in user global.
    • C$Profile exposes profile-related information, not the running user's name.
    • D$CurrentUser is not a valid Visualforce global variable name; the correct one is $User.

Who this Salesforce Certified Platform Developer I practice exam is for

This practice set is for anyone preparing for the Salesforce Certified Platform Developer I exam at the intermediate level - from first-time candidates building a foundation to experienced Salesforce practitioners doing a final review before test day. If you learn best by working through realistic questions and reading why each answer is right or wrong, it is built for you.

How to use this Salesforce Certified Platform Developer I practice exam

1. Start with the free sample questions above to gauge your current baseline.
2. Read the full explanation on every question, including why each wrong option is wrong.
3. Track your weak domains and focus your study where you are losing the most marks.
4. Once you are scoring consistently well, take a timed, full-length mock exam.
5. Use your readiness score to decide when you are ready to book the real Salesforce Certified Platform Developer I exam.

Related Salesforce resources

• Salesforce Certified Platform Developer I study guideKey concepts
• Salesforce practice examsAll Salesforce
• Certification pathWhere this fits
• Certification exam guides & tipsBlog
• Plans & pricingFree & paid
• How these questions are written and reviewedMethodology
• Report a problem with a questionCorrections
• Salesforce Certified Agentforce Sales Consultant practice examRelated
• Salesforce Certified Agentforce Specialist practice examRelated
• Salesforce Certified Business Analyst practice examRelated

Salesforce Certified Platform Developer I practice exam FAQ