Salesforce PD1 Certification: Free Practice Exam & Study Guide (Summer '26)

Apex Governor Limits & the Limits Class

Governor limits prevent any one transaction from monopolising shared platform resources. Key synchronous limits: 100 SOQL queries, 150 DML statements, 50,000 records returned from queries, 6 MB heap size, 10 seconds CPU time. Asynchronous limits are generally 2× the synchronous limits. Use Limits.getQueries() and Limits.getLimitQueries() from the Apex Common Classes (the Limits class) to check usage at runtime. The exam tests which limit applies to a given code scenario and what to change.

Bulkification: Never Put SOQL or DML Inside a Loop

The core Apex pattern: query records before loops using a single SOQL with IN :triggerIdSet, collect changes in a List or Map inside loops, then perform DML after loops. Map<Id, SObject> is the workhorse — used to relate trigger records to queried related records by Id. Use Database.insert(records, false) for partial success (returns SaveResult array). The exam presents code with SOQL/DML in a loop and asks you to identify the issue or fix it.

Apex Triggers: Order of Execution & Handler Pattern

Before triggers fire before the record is saved — use them to validate or modify field values before save (changes to Trigger.new persist without extra DML). After triggers fire after the record is committed — use them when you need the record Id or to update related records. Key context variables: Trigger.new, Trigger.old (not available on insert), Trigger.isInsert, Trigger.isUpdate. Best practice: one trigger per object, all logic delegated to a handler class. The Order of Execution for a save: validation rules → before triggers → system validation → after triggers → workflow rules → DML commit → flows (record-triggered).

SOQL: Relationships, Aggregates & SOSL

Child-to-parent query: SELECT Id, Account.Name FROM Contact (dot notation). Parent-to-child: SELECT Id, (SELECT Id FROM Contacts) FROM Account (subquery). Aggregate functions: COUNT(), SUM(), AVG() — require GROUP BY. SOSL searches multiple objects simultaneously: FIND ’term’ IN ALL FIELDS RETURNING Account, Contact. Use SOSL for cross-object searches; use SOQL when you know the object.

Process Automation: Flow vs. Apex Triggers

The exam tests when to use declarative automation (Flow) vs. programmatic automation (Apex Triggers). Use Flow for standard CRUD operations, approval automation, and complex UI flows without code. Use Apex Triggers when you need cross-object logic beyond Flow’s capabilities, governor limit control, or callout scheduling. Both can fire on the same record — the Order of Execution determines which runs first (Flow runs before After Triggers in record-triggered contexts). Key PD1 topic: if Flow can do it declaratively, prefer Flow; if it needs Apex Classes, Limits, or Database class methods, use Apex.

Testing Framework: SeeAllData, Test.startTest & HttpCalloutMock

Minimum 75% code coverage required across all Apex to deploy to production. Test classes use @isTest. Test data is isolated by default (SeeAllData=false) — create all test data explicitly using @TestSetup or within each test method. Test.startTest() resets governor limits and marks the start of the tested code; Test.stopTest() forces async operations (future methods, batch jobs) to complete synchronously. Mock HTTP callouts with Test.setMock(HttpCalloutMock.class, mockImpl). @TestVisible exposes private members to test classes without making them public.

Lightning Web Components (LWC): Wire Service & @AuraEnabled

LWC is the modern Salesforce UI framework. Key decorators: @track (reactive private properties), @api (public properties exposed to parent), @wire (reactive Apex method calls). The @wire decorator connects an LWC to an Apex method marked @AuraEnabled(cacheable=true) — the cacheable flag is required for @wire. Use lightning-record-form for standard record CRUD without writing Apex. Communication between components uses CustomEvent (child to parent) and LightningMessageService (unrelated components).

Governor Limit Questions — the Pattern to Recognise

The exam will show you Apex code and ask “what is wrong with this code?” The answer is almost always SOQL or DML inside a for loop. Look for for (Account a : accounts) { insert contact; } — that’s DML in a loop, and it will hit the 150 DML statement limit. The fix: collect records in a List inside the loop, then call insert contactList; after the loop. For SOQL: use Maps populated with a single query before the loop, not a query inside the loop.

Testing Questions — the Three Rules to Memorise

(1) Minimum 75% code coverage across the entire org (not per class) to deploy. (2) Test data must be created in the test method — do not rely on org data (@isTest(SeeAllData=false) is the default). (3) HTTP callout tests require a mock implementation — use Test.setMock(HttpCalloutMock.class, mockImpl). Questions often say “a developer’s test class fails when calling an external API” — the answer is always to implement HttpCalloutMock.

Async Apex Selection — Which Method for Which Scenario

Use Future methods for simple one-off async operations (HTTP callouts from triggers, mixed DML). Use Batch Apex when processing more than 10,000 records (up to 50 million). Use Queueable Apex when you need chaining (one job triggers another) or need to pass complex objects between async contexts. Use Scheduled Apex for time-based execution. Exam tip: if the question says “millions of records” or “process in chunks” — the answer is Batch Apex. If it says “chain jobs” — Queueable.

Trigger Scenarios — Before vs After

When the question says “set a field value before the record is saved” — use a before trigger (changes to Trigger.new persist without a DML call). When the question says “create a related record after an account is created” — use an after trigger (the account Id exists after save). When the question says “prevent a record from being saved if a condition is not met” — use addError() in a before trigger. Never call a SOQL query in a trigger without first checking bulkification patterns.

Exam Strategy

PD1 questions often include realistic-looking Apex code snippets. Read code carefully — the “wrong answer” in the options often uses the right method name but in the wrong context (e.g., using a future method where a queueable is needed, or using DML before a callout). Passing score is 68% (41/60 questions). Aim for 78%+ on full mock exams — the additional buffer accounts for exam-day stress and unfamiliar question phrasing. Complete the official Trailhead PD1 Trailmix before booking.