Salesforce Platform Developer II

Hard-coded rules turn into maintenance problems. You choose between custom metadata types and custom settings, and use Apex managed sharing only where rules cannot express the access you need.

• Custom metadata types against custom settings
• Hierarchy and list settings
• Reading configuration efficiently and testing with it
• Deploying configuration with code
• Apex managed sharing and sharing reasons
• Justifying code-based sharing

You build A configurable service driven by custom metadata, with a justified managed sharing rule.

Flows, validation rules, approvals and triggers all run in one transaction. You find where they conflict, reason about recursion and order of execution, and decide which tool should own each piece.

• The order of execution in practice
• Flows and triggers on the same object
• Recursion and re-entry in a transaction
• Trigger frameworks and handler design
• Detecting clashes from debug logs
• Choosing which automation owns the logic

You build A fix for a clashing flow and trigger, with a rule for who owns each behavior.

Asynchronous Apex moves work out of the user’s wait, and each option has different limits. You choose among future methods, queueable jobs, batch and scheduled Apex, and chain and monitor them safely.

• Future methods and their restrictions
• Queueable Apex and chaining
• Queueable finalizers
• Batch Apex for large data sets
• Scheduled Apex and its limits
• Monitoring and recovering failed jobs
• Choosing the right option for a requirement

You build An asynchronous processing design that picks and justifies one mechanism for each task.

Code that works from metadata adapts without changes. You use describe calls, dynamic SOQL and type resolution, and prevent injection and runaway cost when queries are built at run time.

• Schema describe calls
• Dynamic SOQL and bind variables
• Preventing SOQL injection
• Dynamic DML and field access
• Type resolution and the factory pattern
• Cost and limits of dynamic code

You build A metadata-driven utility that builds safe queries from configuration.

Events decouple the sender from every receiver. You publish and subscribe to platform events from Apex, flows and external systems, handle delivery and replay, and know where change data capture is the better fit.

• Defining and publishing platform events
• Subscribing with triggers and flows
• Delivery, retries and replay
• Event publishing behavior and transactions
• Change data capture compared
• Testing event-driven code

You build An event-driven feature with a publisher, a subscriber trigger and replay handling.

Calling out is where transaction limits and the network meet. You build REST and SOAP callouts with named credentials, handle timeouts and long-running requests, and design retries that do not duplicate work.

• REST callouts with named credentials
• SOAP callouts from WSDL
• Limits on callouts and callout timing
• Long-running requests with continuations
• Retries and idempotency
• Exposing Apex as a REST service

You build A callout service with timeouts, retry logic and an inbound REST endpoint.

Teams inherit components, pages and Aura code. You read each against its requirements, understand how the three frameworks interoperate, and decide when to keep, wrap or rewrite.

• Lightning Web Components and their strengths
• Aura components in existing apps
• Visualforce and when it still fits
• Interoperability between the frameworks
• Reading code against requirements
• Deciding to keep, wrap or rewrite

You build A review of three sample components, each with a recommendation.

Components must talk to each other and fit every screen. You use events, message channels and shared state in each framework, and build layouts that respond to devices.

• Custom events and bubbling in Lightning Web Components
• Lightning Message Service across components
• Component and application events in Aura
• Communication in Visualforce pages
• Responsive grids and layout components
• Design for mobile and desktop

You build A set of components that communicate through events and adapt to screen size.

Good tests isolate the code from the outside world. You build mocks for callouts, stubs for dependencies, and test data factories, and write tests that verify behavior instead of chasing coverage.

• HTTP callout mocks and multi-response mocks
• Stub providers and dependency injection
• Test data factories and isolation
• Testing asynchronous code and events
• Asserting behavior and negative cases
• Reading coverage honestly

You build A test suite for a callout service built with mocks and stubs.

Interface faults hide in the browser as much as on the server. You debug with browser developer tools, debug mode for components, view state and logs, and trace a fault from screen to Apex.

• Browser developer tools for components
• Debug mode for Lightning components
• Reading Visualforce view state
• Debug logs and the Apex Replay Debugger
• Tracing a defect from screen to server
• Writing a regression test for a defect

You build A defect investigation write-up that traces a bug from screen to cause.

Deployments should be built from source, not rebuilt by hand. You set up a source-driven workflow with scratch orgs, the CLI and automated tests, and see how it fits a team’s branching and release routine.

• Source format and project structure
• Scratch orgs for isolated development
• CLI deployments and validations
• Running tests in a pipeline
• Versioned releases and rollback
• Handling metadata dependencies

You build A source-driven pipeline that validates and deploys a feature with tests.

Slow code shows up at volume. You find slow interfaces and wasteful queries, choose data structures that avoid repeated work, structure queries for large data volumes and use asynchronous callouts.

• Finding slow interfaces with timing and logs
• Selective queries and index use
• Collections that avoid repeated queries and loops
• Querying large data volumes safely
• Asynchronous callouts in the interface
• Caching and reducing round trips

You build A before-and-after performance fix for a slow page and its queries.

Build one feature that needs automation, events, callouts, an interface and tests. You choose each mechanism on evidence, deploy it from source and show how it behaves at volume.

• Scoping a feature and its volume targets
• Choosing automation, async and event mechanisms
• Building interface and integration pieces
• Testing, deploying and measuring at volume
• Reviewing the design and its trade-offs

You build A complete feature, deployed from source and measured at volume.