Salesforce Certified Platform Developer II – Complete Winter '26 Guide

Design Patterns for Enterprise Apex

The exam tests four core patterns. Singleton ensures one shared class instance per transaction — used for handler registries and settings caches. Factory creates objects dynamically based on runtime type. Strategy encapsulates interchangeable algorithms in separate classes — ideal for pricing or routing logic that varies by record type. Trigger Handler separates trigger logic from business logic, enabling testable, single-responsibility handler classes. Know which pattern a given code smell or requirement maps to.

Asynchronous Apex: Choosing the Right Context

@future — simplest async, no complex parameters, no chaining, no job IDs. Queueable — supports complex sObject parameters, job chaining (enqueue from finish), and returns AsyncApexJob ID. Batch Apex — processes up to 50 million records in chunks; implement Database.Stateful to retain instance variables across iterations; chain in finish() via Database.executeBatch(). Schedulable — time-based entry point; use to kick off Batch or Queueable. The exam presents a scenario and asks which context is appropriate.

Integration: Callouts, Named Credentials, and Platform Events

Callouts cannot be made from synchronous triggers — use @future(callout=true) or Queueable with Database.AllowsCallouts. Named Credentials store the endpoint URL and authentication credentials securely, referenced in Apex as callout:NamedCredName. Platform Events provide loosely coupled, fire-and-forget publish/subscribe messaging — publishers do not wait for subscribers. Change Data Capture streams record change events to external systems without polling. The exam tests when each mechanism is appropriate.

Testing Strategy: Setup, Mocking, and Coverage

@TestSetup creates test data once for all test methods in the class, preventing repeated DML and improving performance. Test.startTest() / Test.stopTest() resets governor limits for the code under test and forces async jobs to complete. Mock callouts using HttpCalloutMock (implement the interface) or StaticResourceCalloutMock (use a static resource JSON file). System.assert patterns: assertEquals(expected, actual), assertNotEquals, assertTrue — always provide a meaningful message. 75% code coverage is required for deployment.

Security in Apex: Sharing, FLS, and AuraEnabled

with sharing enforces the running user's sharing rules; without sharing bypasses them; inherited sharing inherits from caller context. Classes default to without sharing if unspecified — a PD2-level trap. FLS enforcement: use Schema.SObjectType.getDescribe().fields.getMap() to check field accessibility, or stripInaccessible() to filter query results. @AuraEnabled exposes methods to LWC and Aura components — always combine with FLS and sharing checks. CRUD checks require Schema.SObjectType.Account.isCreateable() style checks.

Asynchronous Apex Mastery

Know all four async patterns: Queueable (chainable, stateful), Batch (large data sets), Scheduled (time-based), and Future (simple async). Understand governor limits in async contexts (higher SOQL/DML limits) and when each pattern is appropriate.

Integration Architecture Decisions

REST vs. SOAP vs. Platform Events vs. Change Data Capture — know the use cases for each. Understand outbound messaging, callout limits, Named Credentials, and how to handle integration errors gracefully.

Platform Events & Event-Driven Architecture

Know how Platform Events enable event-driven, decoupled architectures. Understand the difference between Platform Events and CDC, how to publish events from Apex and Flows, and how subscribers process events reliably.

LWC Advanced Patterns

Understand component communication patterns: parent-to-child via properties, child-to-parent via custom events, and sibling communication via a shared service. Know when to use @wire vs. imperative Apex calls.

Testing Architecture

PD2 emphasizes test design: mock callouts with Test.setMock, test data isolation (SeeAllData=false), testing async Apex with Test.startTest/stopTest, and achieving meaningful code coverage vs. superficial coverage.