Platform Developer

Understand multi-tenant concepts and design frameworks such as MVC architecture and the Lightning Component Framework.

Every Salesforce org shares infrastructure with every other org. That single fact explains governor limits, the three annual releases that arrive automatically, and much of what makes development on the platform different from building on a server of one’s own. Candidates should also be able to place platform features in the MVC pattern, with objects and fields as the model, Apex and controllers as the logic layer, and Lightning pages, components, and Visualforce as the view, and to describe the component-based structure of the Lightning Component Framework.

Given a scenario, identify common use cases and best practices for declarative versus programmatic customization, including governor limits, formula fields, and roll-up summaries.

Declarative capability grows with every release, and the exam rewards the developer who writes code only where clicks fall short. Candidates should know what formula fields and roll-up summary fields can and cannot do, including the master-detail requirement for roll-ups and the fact that formulas calculate when a record is read rather than storing a value, and should weigh governor limits when choosing between an automation and a trigger.

Given a scenario, determine, create, and access the appropriate data model, including objects, fields, relationships, and external IDs.

The data model is where most development starts. Candidates need to choose between standard and custom objects, pick field types that hold up over time, and select the relationship that fits the business need. External IDs matter for upserts and for matching records that come from another system. Accessing the model in code brings its own rules, including dot notation for child-to-parent references, subqueries for parent-to-child, and the relationship names that custom relationships use.

Relationship types:

• Lookup
• Master-detail
• Many-to-many
• External lookup
• Indirect lookup
• Hierarchical

Understand the use cases and limitations of Agentforce for Developers.

Agentforce for Developers is the AI assistant built into Visual Studio Code and Code Builder for Salesforce DX projects. It generates Apex from natural language prompts, suggests inline completions in Apex and Lightning Web Component files, creates Apex unit tests, and explains or documents existing code through slash commands. The limitations matter as much as the features: suggestions are a starting point that still needs review, testing, and the developer’s judgment before anything reaches production.

Identify the capabilities of the declarative process automation features.

Flow Builder is the declarative automation tool, following the retirement of Workflow Rules and Process Builder. Candidates should know what each flow type does, how record-triggered flows run before or after save, and how approvals, formula fields, validation rules, and roll-up summaries fit alongside them. The recurring exam question is which requirement can be met without code at all.

Understand how to declare variables, constants, methods, modifiers, and Apex interfaces, and the use cases for each.

Apex is strongly typed and follows Java conventions. Candidates should be comfortable with primitive and complex data types, collections such as list, set, and map, sObject types, enums, static versus instance members, and access modifiers including private, public, global, and protected. An interface defines a contract without implementing it, which is what makes patterns such as invocable or pluggable logic possible.

Given a scenario, assess how Apex control flow statements will execute and when to apply each one.

Control flow questions are often a trace exercise: read the code and say what it returns. Candidates should be fluent with if and else, switch, for loops in each of their forms including the SOQL for loop, while and do-while, and the break and continue statements, and should recognize the loop patterns that put SOQL or DML where they will hit a limit.

Given a scenario, write SOSL, SOQL, and DML statements in Apex, and assess what they return.

SOQL queries structured data on a known object and its relationships. SOSL searches text across several objects at once and returns a list of lists. DML inserts, updates, upserts, deletes, undeletes, and merges records. Candidates should know when each applies, how to write relationship queries, and how partial success behaves with Database methods and the allOrNone option.

Given a scenario, follow best practices when writing Apex classes and triggers.

Trigger best practice is well established and heavily tested: one trigger per object, logic moved into a handler class, bulk-safe code that never puts SOQL or DML inside a loop, and guards against recursion. Candidates should know the trigger context variables, when to use before versus after events, and how to keep classes small enough to test and reuse.

Given a scenario, understand governor limits and their implications for Apex transactions.

Limits apply per transaction, not per line of code. Candidates should know the headline synchronous limits, including 100 SOQL queries, 150 DML statements, 50,000 records retrieved by SOQL, and 10,000 milliseconds of CPU time, along with the higher limits available asynchronously. They should also be able to read a scenario and say which limit a design will hit first.

Describe the relationship between Apex transactions, the save order of execution, and the potential for recursion and cascading.

The order of execution explains behavior that otherwise looks random: when before and after triggers fire, where validation rules and duplicate rules sit, when roll-up summaries recalculate, and where record-triggered flows run. Candidates should be able to trace a save from start to finish and to explain how one automation can trigger another, producing cascading updates or recursion.

Implement exception handling in Apex, including custom exceptions.

An unhandled exception stops processing and rolls back the transaction. Candidates should be comfortable with try, catch, and finally, the built-in exception types such as DmlException, NullPointerException, and QueryException, the methods available on an exception, and defining a custom exception class that extends Exception for errors specific to the application.

Given a scenario, use declarative functionality and Apex together to automate business logic.

The two sides are designed to meet. An invocable Apex method can be called as an action from a flow, a flow can be launched from Apex, and a well-drawn boundary keeps the declarative parts editable by an admin while the complex logic stays in code. Candidates should be able to recommend where that boundary sits for a given requirement.

Given a scenario, prevent user interface and data access security vulnerabilities.

Code does not enforce sharing, object, or field security on its own. Candidates should know the classic vulnerabilities, including SOQL injection, cross-site scripting, and cross-site request forgery, and the defenses that apply: bind variables and escaping, the with sharing and without sharing keywords, user mode database operations, and methods that strip fields the running user cannot see.

Given a scenario, display and use custom user interface components, including Lightning components, Flow, and Visualforce.

The platform offers several ways to put a custom interface in front of a user, and the exam expects a sensible choice among them. Candidates should know where each one can be surfaced, such as Lightning App Builder pages, quick actions, flow screens, Experience Cloud sites, and Visualforce pages reached from tabs, buttons, or page layouts.

Describe the use cases and best practices for Lightning Web Components, including the framework, its benefits, and events.

Lightning Web Components are built on standard web technologies, which is the main reason they perform better and are quicker to learn than Aura. Candidates should know what a component bundle contains, including the HTML template, JavaScript class, optional CSS, and the metadata configuration file that decides where the component can be used. Communication matters too: public properties and methods with the api decorator, wire adapters for data, and custom events that travel up the component hierarchy.

Given a scenario, implement Apex to work with page components, including Lightning components, Flow, and Agentforce.

Apex supplies data and logic to the interface. Candidates should know how AuraEnabled methods are called from a Lightning component, when a cacheable method is appropriate, how wire adapters consume Apex, how invocable methods appear as actions in Flow, and how Apex can be exposed as an action an Agentforce agent calls.

Write and execute tests for triggers, controllers, classes, and flows using various sources of test data.

Salesforce requires tests before code reaches production, which makes this topic practical rather than theoretical. Candidates should know how test classes are structured with the isTest annotation, how test setup methods and data factories create records, that tests see no org data unless they are told otherwise, how Test.startTest and Test.stopTest reset limits and force asynchronous work to run, and how runAs checks behavior under a different user’s permissions. Flow tests cover record-triggered flows in the same spirit.

Given a scenario, know how and when to use Salesforce developer tools such as Salesforce DX, Salesforce CLI, and the Developer Console.

Each tool has a job. Salesforce DX and the CLI support source-driven development, scratch orgs, and repeatable deployments from a version-controlled project. The Developer Console is convenient for quick edits, running anonymous Apex, inspecting logs, and running tests. VS Code with the Salesforce extensions is where most day-to-day work happens.

Describe how to approach debugging system issues and monitoring flows, performance, asynchronous jobs, and batch jobs.

Debugging starts with the debug log, which means knowing how trace flags, log levels, and log limits work. Beyond logs, candidates should know where to watch flow errors and paused interviews, how to check queued, running, and failed jobs in Apex Jobs and the flex queue, and how to read a scenario and decide whether the problem is logic, limits, or timing.

Describe the environments, requirements, and process for deploying code and the configuration that goes with it.

Deployment questions cover both the destination and the route. Candidates should know the sandbox types and scratch orgs and what each suits, the options for moving metadata including change sets, the CLI, and packages, and the requirements Salesforce enforces on a production deployment, including the 75% code coverage rule, the requirement that every trigger has some coverage, and the tests that run as part of the deployment.