Salesforce Accredited B2B Commerce Developer Professional (AP-202) Exam Topics and Questions
These Salesforce Accredited B2B Commerce Developer Professional (AP-202) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise Salesforce Accredited B2B Commerce Developer Professional (AP-202) sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the Salesforce Accredited B2B Commerce Developer Professional certification exam.
Let's Practice Free Salesforce Accredited B2B Commerce Developer Professional (AP-202) Questions Aligned with Official Exam Topics
Checkout is where deals convert or collapse. This topic covers customisation of existing checkout flows to meet customer requirements while keeping the storefront responsive and predictable. The cost comes when you modify flow logic without understanding how state is managed across steps, or when you introduce a customisation that works in isolation but breaks under load or in edge cases. How Checkout Flow Development is tested Ten per cent of the marks come from this area, so expect two or...
Checkout is where deals convert or collapse. This topic covers customisation of existing checkout flows to meet customer requirements while keeping the storefront responsive and predictable. The cost comes when you modify flow logic without understanding how state is managed across steps, or when you introduce a customisation that works in isolation but breaks under load or in edge cases.
How Checkout Flow Development is tested
Ten percent of the marks come from this area, so expect two or three items that test your ability to choose the right customisation point and avoid common mistakes. Questions present a scenario where a business requirement conflicts with default behaviour, then ask which approach preserves data integrity and user experience. You lose marks when you pick a solution that works in a demo but fails when a user navigates backward through the flow, when session state is lost, or when an integration times out. The examinable skill is recognising which part of the flow to extend and which to leave alone, not reciting what the checkout object model contains.
Checkout logic is tested through scenario-based items that assume you have seen the failure modes in practice. The practice test lets you work through those scenarios under time pressure, and the PDF gives you a second pass without the clock so you can identify which customisation points you are confusing.
The question below asks you to choose the safest customisation approach when a requirement conflicts with default checkout behaviour.
A developer attempts to export data from an org by launching Data Loader, selecting a standard entity, clicking the "Select All Fields" button and clicking the Finish button. The developer finds that the CustomField_c field they added to the entity has no values under the header in the CSV file output. What is the root cause?
Reference implementations provide the scaffolding for checkout and payment interfaces. You work with four of them, and the exam assumes you know which actions each supports and when to extend versus replace. The challenge is that the implementations look similar in structure but differ in the actions they expose and the contracts they enforce. Mistakes happen when you call an unsupported action or misunderstand the sequence in which actions fire. β The four implementations and their contracts Each reference implementation...
Reference implementations provide the scaffolding for checkout and payment interfaces. You work with four of them, and the exam assumes you know which actions each supports and when to extend versus replace. The challenge is that the implementations look similar in structure but differ in the actions they expose and the contracts they enforce. Mistakes happen when you call an unsupported action or misunderstand the sequence in which actions fire.
β The four implementations and their contracts
Each reference implementation handles a distinct part of the checkout or payment process, and each exposes a specific set of actions you can invoke or override. The exam tests whether you know which implementation governs which part of the flow and what happens when you try to use an action outside its intended context. You need to distinguish between implementations that manage cart state, those that handle payment authorisation, and those that coordinate order submission. The contract each implementation enforces matters because violating it causes silent failures or rollback behaviour that is hard to diagnose. Coverage includes knowing which actions are synchronous, which are asynchronous, and how errors propagate when an action fails partway through a multi-step process.
β Extending and replacing actions
Supported actions can be extended or replaced depending on the requirement, and the exam asks you to choose the approach that preserves platform behaviour while meeting the business need. Extension keeps the default logic and adds your own before or after it. Replacement discards the default entirely, which is sometimes necessary but often dangerous because you inherit responsibility for everything the platform was doing. Questions present a scenario where the default action almost works, then ask whether you extend, replace, or configure. You lose marks when you replace an action to avoid learning what it does, or when you extend in a way that duplicates platform logic and causes the same operation to run twice.
How Reference Implementations is tested
Fifteen percent weighting means three or four items, typically split between identifying the correct implementation for a given requirement and choosing the right way to modify a supported action. Questions describe a checkout or payment scenario, then ask which implementation and which action you would use. Wrong answers include implementations that seem plausible but do not support the action in the stem, or approaches that work in a sandbox but violate the contract in production. You lose marks by confusing which implementation owns which part of the flow, or by choosing to replace an action when extension would have been safer and sufficient. The exam rewards candidates who have read the action signatures and tested what happens when an action fails.
Reference implementations are tested through questions that assume you have worked with each one and seen what happens when you pick the wrong action or violate a contract. The practice test shows you the question style, and the PDF lets you review every implementation scenario without the timer running.
The question below presents a payment requirement and asks which implementation and action combination will meet it without breaking the contract.
A configuration value, CO.NewOrder, is set to TRUE. What is one way of
preventing anexisting payment page from being shown on the checkout payment page?
Enhancing existing Lightning Web Components means modifying behaviour or presentation without rebuilding the component from scratch. Twenty per cent of the exam comes from this area, so it is the first of the two component topics and the one that tests whether you can work within the constraints of a component someone else wrote. The difficulty is knowing which properties and methods are safe to override, which are part of the public API, and which will break when the platform...
Enhancing existing Lightning Web Components means modifying behaviour or presentation without rebuilding the component from scratch. Twenty percent of the exam comes from this area, so it is the first of the two component topics and the one that tests whether you can work within the constraints of a component someone else wrote. The difficulty is knowing which properties and methods are safe to override, which are part of the public API, and which will break when the platform updates. Errors cluster around lifecycle hooks, event handling, and state management.
How Basic Lightning Web Component Development is tested
Twenty percent means four or five items. Expect questions that show you a component with a specific shortcoming, then ask how to enhance it without replacing it or breaking its existing consumers. The scenarios test your understanding of component lifecycle, property reactivity, and event propagation. You lose marks when you modify a private method that the platform depends on, when you introduce a change that works in isolation but fails when the component is used inside a parent, or when you add a property without making it reactive and the UI does not update. The exam also tests whether you know when an enhancement is not viable and a new component is the only safe path, but that crossover belongs to the advanced topic. Focus here is on working within the existing structure.
Enhancement scenarios require you to recognise safe modification points quickly. The practice test gives you timed exposure to the decision patterns, and the PDF lets you compare similar scenarios side by side to spot the differences that change the answer.
The question below describes a component that needs modified behaviour and asks which enhancement approach preserves compatibility with existing consumers.
Creating new components from scratch is the heaviest topic on the exam. Thirty per cent means you will face five or six items that assume you have built components in a production storefront and dealt with the problems that only appear when real users interact with them. The shift from basic to advanced is the shift from modifying to authoring, and the cost is higher because you own the entire component contract: lifecycle, state, events, error boundaries, and accessibility. β...
Creating new components from scratch is the heaviest topic on the exam. Thirty percent means you will face five or six items that assume you have built components in a production storefront and dealt with the problems that only appear when real users interact with them. The shift from basic to advanced is the shift from modifying to authoring, and the cost is higher because you own the entire component contract: lifecycle, state, events, error boundaries, and accessibility.
β Component architecture and state
A new component starts with decisions about where state lives, how it flows between parent and child, and when it needs to be persisted or discarded. The exam tests whether you know the difference between component state, application state, and server state, and whether you can choose the right mechanism for each. Questions present a requirement that involves multiple components sharing data, then ask how to structure the state so that changes propagate correctly and the UI stays in sync. You lose marks when you lift state too high and cause unnecessary re-renders, or when you keep it too local and lose it on navigation. Coverage includes reactive properties, wire adapters, and imperative calls to Apex, with attention to what happens when a call fails or returns stale data.
β Lifecycle and rendering
Lifecycle hooks control when your component initialises, updates, and cleans up, and mistakes in this area cause memory leaks, duplicate API calls, or UI flicker. The exam asks you to choose the correct hook for a given task and to recognise what happens when you perform an expensive operation in the wrong part of the lifecycle. You need to know when connectedCallback runs, when renderedCallback runs, and when disconnectedCallback is your responsibility versus when the platform handles it. Questions also cover conditional rendering and what happens when a component is removed from the DOM and then re-added, which is common in storefront navigation. You lose marks when you fetch data in renderedCallback and cause an infinite loop, or when you fail to clean up event listeners and the component continues to respond after it is unmounted.
β Events and communication
Components communicate through events, public properties, and sometimes a shared service. The exam tests your ability to choose the right mechanism and to structure event payloads so that consumers can act on them without coupling tightly to the component that fired them. Custom events need to bubble or compose correctly depending on where the listener lives, and you need to know when to use a platform event versus a component event. Questions describe a scenario where a child component needs to notify a parent or a sibling, then ask which event strategy to use. You lose marks when you pass too much data in the event and create a dependency on internal state, or when you fail to stop propagation and the event triggers multiple handlers unintentionally.
β Error handling and accessibility
A production component must handle errors gracefully and remain accessible to all users. The exam includes scenarios where an Apex call fails, a wire adapter returns an error, or a user provides invalid input, and asks how your component should respond. You need to know how to use error boundaries, how to display error messages without breaking the layout, and when to log versus when to show the user a recoverable path. Accessibility coverage includes semantic HTML, ARIA attributes, keyboard navigation, and focus management. You lose marks when you build a component that works with a mouse but is unusable with a keyboard, or when you display an error in a way that a screen reader cannot announce. The exam assumes you have tested your components with assistive technology, not just read the documentation.
How Advanced Lightning Web Component Development is tested
Thirty percent is the largest share of the exam, so expect five or six items that test component authoring in realistic storefront scenarios. Questions describe a requirement that cannot be met by enhancing an existing component, then ask you to design a new one. The scenarios involve state management, lifecycle decisions, event design, and error handling, often in combination. You lose marks when you choose a lifecycle hook that causes performance problems, when you structure state in a way that does not survive navigation, or when you omit error handling and the component breaks silently when an integration fails. The exam rewards candidates who have debugged their own components in a live storefront and learned which design decisions cause problems at scale.
Component authoring questions assume you have built and debugged your own work. The practice test gives you scenario-based items that mirror production complexity, and the PDF format is useful for reviewing your answers and identifying which architectural decisions you are misjudging.
The question below asks you to design a new component for a storefront requirement, focusing on state management and lifecycle decisions.
Data management covers relationships, integrations, and the decisions that determine whether a storefront can scale beyond the pilot. Fifteen per cent means this is a mid-weight topic, and the exam tests your ability to structure data so that queries remain efficient, integrations stay reliable, and administrators can maintain the system without developer intervention. The pain points are relationship design, data volume, and integration error handling. β Relationships and schema design B2B storefronts depend on relationships between accounts, contacts, products, price...
Data management covers relationships, integrations, and the decisions that determine whether a storefront can scale beyond the pilot. Fifteen percent means this is a mid-weight topic, and the exam tests your ability to structure data so that queries remain efficient, integrations stay reliable, and administrators can maintain the system without developer intervention. The pain points are relationship design, data volume, and integration error handling.
β Relationships and schema design
B2B storefronts depend on relationships between accounts, contacts, products, price books, orders, and custom objects. The exam tests whether you know how to structure those relationships so that queries perform well and data integrity is preserved when records are deleted or reassigned. You need to understand lookup versus master-detail, when to use a junction object, and how relationship queries affect governor limits when the data set grows. Questions present a requirement that involves linking objects, then ask which relationship type to use and what happens when a parent record is deleted. You lose marks when you choose a relationship that causes cascading deletes you did not intend, or when your query traverses too many levels and hits a limit under load.
β Integrations and error recovery
Storefronts integrate with ERP, payment gateways, inventory systems, and other external services. The exam assumes you have built integrations that handle timeouts, partial failures, and data format mismatches. You need to know when to use platform events versus outbound messages, how to structure callouts so that failures can be retried, and when to persist integration state so that a failed transaction can be resumed. Questions describe an integration scenario where the external system is unreliable, then ask how to design the flow so that data is not lost and the user receives meaningful feedback. You lose marks when you build a synchronous integration that blocks the checkout flow, or when you fail to log enough information to diagnose why an integration failed in production.
How Data Management is tested
Fifteen percent means three or four items focused on schema decisions and integration design. Questions present a storefront requirement that involves relating objects or calling an external system, then ask which approach will scale and recover from failure. You lose marks when you design a relationship that performs well in a sandbox with a hundred records but fails in production with a hundred thousand, or when you build an integration that works in happy-path testing but has no retry logic and loses data when the network is unstable. The exam tests whether you have thought about data volume, governor limits, and what happens when things go wrong. Correct answers reflect experience with production storefronts, not just knowledge of the object model.
Data and integration questions test your ability to design for scale and failure. The practice test exposes you to the scenario style, and the PDF lets you work through each question carefully to see where your schema or integration assumptions are wrong.
The question below presents a storefront data requirement and asks which relationship or integration design will handle scale and failure correctly.
Troubleshooting is the skill that separates candidates who have run a storefront in production from those who have only worked in a sandbox. Ten per cent of the exam tests your ability to use the available diagnostic tools to isolate a problem, interpret what the logs are telling you, and choose a fix that addresses the cause rather than the symptom. The difficulty is that B2B Commerce errors often appear in one place but originate in another, and the tools...
Troubleshooting is the skill that separates candidates who have run a storefront in production from those who have only worked in a sandbox. Ten percent of the exam tests your ability to use the available diagnostic tools to isolate a problem, interpret what the logs are telling you, and choose a fix that addresses the cause rather than the symptom. The difficulty is that B2B Commerce errors often appear in one place but originate in another, and the tools give you more data than you can process unless you know what to filter.
How Error Handling and Diagnostics is tested
Ten percent means two or three items that describe a storefront failure and ask which diagnostic tool or log entry will reveal the cause. Questions present symptoms like a checkout that fails silently, a component that does not render, or an integration that returns inconsistent results, then ask what you would check first. You lose marks when you guess at a fix without consulting the logs, or when you look at the wrong log level and miss the entry that explains the failure. The exam tests whether you know how to use debug logs, developer console, network traces, and the built-in diagnostics for checkout and payment flows. It also tests whether you understand error propagation, so you can trace a failure from the UI back through the component, the controller, the service layer, and the integration. Correct answers reflect a methodical approach to diagnosis, not intuition.
Diagnostic questions assume you have used the tools under pressure to fix a live issue. The practice test gives you timed scenarios where you must choose the right diagnostic step quickly, and the PDF lets you review each scenario to confirm you understand why the other options would not reveal the cause.
The question below describes a storefront error and asks which diagnostic tool or log entry will isolate the root cause most efficiently.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Salesforce Accredited B2B Commerce Developer Professional (AP-202) Exam Questions π