The four checkout reference implementations in Salesforce B2B Commerce have specific names, specific interfaces, and specific methods that the AP-202 exam tests at the implementation detail level – and candidates who know that reference implementations exist but have not built one in a sandbox consistently get these questions wrong. CartPriceCalculations handles pricing logic at the cart level. CartShippingCharges calculates shipping costs. CartInventoryValidation verifies product availability. CartTaxCalculations computes tax amounts. Each of these is an Apex class that implements a specific platform interface, and each interface requires implementing a specific method with a specific signature. The exam presents a scenario – “a developer needs to integrate a third-party tax service to calculate taxes during checkout” – and asks which reference implementation interface to implement, what method the class must define, and what data is available in the method context for the calculation. Candidates who have studied that tax calculation is handled by the CartTaxCalculations reference implementation but have not worked through the interface definition, the method signature, or what inputs the platform provides will arrive at a correct category (tax implementation) but will not recognize the correct answer among the options that test implementation specifics. Building at least one reference implementation in a sandbox before sitting the exam is the single most impactful preparation step for the AP-202.
The Salesforce AP-202 (B2B Commerce for Developers Accredited Professional) certifies development expertise for customizing Salesforce B2B Commerce storefronts. Six exam domains: Checkout Flow Development, Reference Implementations, Basic Lightning Web Component Development, Advanced LWC Development, Data Management, and Error Handling and Diagnostics. Sixty questions, 65% passing.
Cert Empire’s AP-202 exam questions cover all six domains at the implementation detail depth the real exam requires – specifically the four reference implementation interfaces, the checkout flow step structure, and the LWC patterns for commerce component overrides.
Exam Snapshot
| Field | Details |
| Exam Code | AP-202 |
| Exam Name | B2B Commerce for Developers Accredited Professional |
| Vendor | Salesforce |
| Number of Questions | 60 |
| Passing Score | 65% (~39 of 60) |
| Cost | USD $200 |
| Delivery | Salesforce certification portal |
| Target Audience | Salesforce developers with B2B Commerce customization experience; 1+ year of Salesforce development + B2B Commerce exposure |
Domain 1: Checkout Flow Development
The checkout flow as a Screen Flow: B2B Commerce checkout is implemented as a Salesforce Screen Flow – a visual flow that users move through during the purchase process. The flow presents screens for address selection, delivery method, payment, and order review in sequence. Administrators can reorder, add, or remove steps using Flow Builder without code. Developers extend the checkout by implementing custom LWC components that integrate within the flow.
Checkout subflow structure: The checkout flow is composed of subflows – individual flow components that handle specific checkout stages. Each subflow has a next-state attribute that determines which subflow runs after it completes. To reorder checkout steps, a developer adjusts the next-state attribute of the preceding subflow to point to the new next step – not modifying the main flow’s structure itself. A confirmed AP-202 question: what must a developer modify to reorder a checkout flow step? Answer: the next-state attribute in the configuration of the preceding subflow.
Custom child checkout components: Developers can implement custom child components within a checkout step by implementing the CheckoutStep interface. This interface requires implementing specific callback methods that the checkout flow uses to validate the step before allowing the buyer to proceed. The exam tests which interface a custom child checkout component must implement and what the required method signatures are.
Conditional payment logic: A business requirement for conditional payment display (e.g., showing credit card only for orders above $5,000) requires a custom LWC child component that pulls account data, evaluates the cart total, and conditionally renders payment options. The implementation uses @api and @wire decorators to access cart and account data within the component. The exam tests the implementation approach – a custom LWC child component using decorators to access commerce data, not a gateway configuration or a subflow decision element.
CheckoutTimeToLive management: When a buyer abandons checkout mid-flow, the checkout session remains locked until it expires. The exam tests how to configure session expiry: finding the WebCart record and updating the CheckoutTimeToLive and CheckoutValidAfterDate properties.
Domain 2: Reference Implementations – The Four Interfaces
This is the most distinctively AP-202 content area and the most implementation-specific.
CartPriceCalculations
This interface handles custom pricing logic at the cart level. When should a developer implement CartPriceCalculations instead of using standard B2B Commerce price books? When pricing logic requires: calling an external pricing service (ERP pricing engine, contract-specific pricing system), applying pricing rules that cannot be expressed in standard price book entries, or calculating volume discounts based on cross-product quantities rather than per-line quantities.
The exam tests: which class is the subscriber (the developer’s implementation class), what interface the class implements, and what method the platform calls when pricing calculation is needed. The method receives a cart record context that provides access to the cart’s line items, buyer account, and current prices for manipulation.
CartShippingCharges
This interface integrates external shipping rate calculation. It is called when the buyer reaches the delivery step and requests shipping options. The implementation receives the cart context (including line items, buyer address, and requested delivery date) and must return a list of available shipping options with calculated rates.
The exam tests when CartShippingCharges is used versus when standard delivery methods configured in B2B Commerce administration are sufficient. Standard delivery methods are configured by administrators with fixed or calculated rates. CartShippingCharges is necessary when rates must come from an external carrier API in real time based on item weight, dimensions, and delivery address.
CartInventoryValidation
This interface validates whether the items in the cart are available for purchase before checkout proceeds. It is called at checkout initiation and can prevent checkout from proceeding if items are unavailable or available in insufficient quantities.
The exam tests the inventory validation workflow: the platform calls the validation method, the developer’s implementation checks inventory (through Salesforce inventory records or an external inventory system), and returns a result indicating whether each cart item passes or fails validation. Failed items can be removed from the cart or flagged for buyer attention.
CartTaxCalculations
This interface integrates external tax calculation services. It is called when checkout reaches the review step and calculates the tax amounts that will be applied to the order. The implementation receives cart line items with their amounts and addresses, calls the tax service, and returns calculated tax amounts that the checkout flow applies.
The exam tests the CartTaxCalculations interface in detail: what the calculate method receives as input (a CartExtension.CartContext object providing access to cart items, delivery address, and buyer account), and what it must return (tax amounts for each cart item plus the overall order). The exam presents scenarios where a developer needs to integrate a specific third-party tax provider and asks which interface and method structure satisfies the requirement.
Domain 3: Basic Lightning Web Component Development
Commerce-scoped modules: Custom storefront LWCs use Salesforce Commerce-specific scoped modules (@salesforce/commerce) to access cart data, product data, and checkout context reactively. These modules follow the same wire service pattern as standard LWC data access but are specific to the commerce context.
Wire adapters for commerce: The wire service connects LWC properties to Salesforce data sources reactively. For B2B Commerce, wire adapters provide: current cart data, product detail information, and buyer account information. When the underlying data changes (cart item added, price updated), wire-connected properties update automatically without manual data fetching.
The @api and @wire decorators in checkout components: In checkout context, @api exposes properties that the parent checkout flow passes to the child component (cart total, buyer address, available payment methods). @wire connects the component to live Salesforce data sources. The exam tests when each decorator is appropriate and how they work together to build a checkout component that responds to both parent-passed data and live Salesforce state.
Component lifecycle hooks: The LWC lifecycle (connectedCallback, renderedCallback, disconnectedCallback) controls component behavior at specific points. The exam tests when each is appropriate: connectedCallback for initialization and data fetching that should happen when the component inserts into the DOM, renderedCallback for logic that needs DOM access after rendering.
Domain 4: Advanced LWC Development
The component override pattern: B2B Commerce uses a component override mechanism to replace default storefront components with custom implementations. A developer creates a custom LWC, registers it in the Community Builder component map as an override for a specific standard component, and the storefront renders the custom component instead of the default. The exam tests how overrides are registered and what constraints apply – custom components must implement any interface that the standard component implements to maintain compatibility with the checkout flow.
Event-driven communication in commerce components: LWC uses custom events for parent-child communication (child dispatches events, parent handles them) and Lightning Message Service for cross-component communication that spans separate parts of the DOM. The exam tests when to use custom events (within a component hierarchy) versus Lightning Message Service (between unrelated components on the same page).
The Commerce Connect API (Connect in Apex): The Connect in Apex framework provides programmatic access to storefront operations from Apex classes. Developers use it for custom checkout logic that needs to read or modify cart state, create orders, or access product and pricing data. The exam tests which operations are available through Connect in Apex and when a developer should use it versus standard DML.
Domain 5: Data Management
The B2B Commerce data model for developers: The key objects developers query and manipulate: WebStore (storefront configuration), WebCart and CartItem (the shopping cart and its line items), WebCartAdjustmentGroup (discount grouping on the cart), Order and OrderItem (the placed order), Product2 (the product record), Pricebook2 and PricebookEntry (pricing). The exam tests SOQL queries across these objects and the relationship traversal required to access cart items with product information, buyer account data, and pricing in a single query.
External Objects and Salesforce Connect: When historical data (archived orders, usage records, billing history) exists in external systems and must be accessible from within Salesforce without storage cost, External Objects (via Salesforce Connect) provide read-only access to external data through a virtual object that appears to be a Salesforce record but is never stored in Salesforce. The exam presents a requirement to access external data without replication into Salesforce and tests that External Objects (not callouts, not middleware) is the declarative solution.
Data import and external ID usage: When importing large data sets (product catalogs, account hierarchies, price book entries), External IDs preserve relationships during import without requiring Salesforce record IDs from the source system. The exam tests how External IDs are used to maintain referential integrity during B2B Commerce data loads.
Domain 6: Error Handling and Diagnostics
Checkout flow error surface: When a reference implementation method throws an exception, the checkout flow must handle it without breaking the buyer’s session. The exam tests how to implement try-catch patterns in reference implementations, what error information to return to the platform (error messages that the checkout flow can surface to the buyer), and how to distinguish recoverable errors (validation failure the buyer can correct) from fatal errors (system unavailability requiring support escalation).
Debugging Commerce implementations: The exam tests available diagnostic tools for B2B Commerce: Salesforce debug logs for Apex execution tracing, network logs for HTTP request/response inspection in the browser, and the Commerce Debug Log (a Commerce-specific logging facility for tracking checkout flow execution).
5 Study Tips for Salesforce AP-202
- Tip 1: Build all four reference implementations in a developer sandbox before the exam. The exam tests the interface class names, method signatures, and input parameters for CartPriceCalculations, CartShippingCharges, CartInventoryValidation, and CartTaxCalculations. No amount of reading substitutes for having implemented these interfaces directly.
- Tip 2: Study the next-state attribute in checkout subflow configuration. The exam tests checkout step reordering and the specific attribute that controls step sequencing.
- Tip 3: Know the CheckoutStep interface name and what it requires. Custom child checkout components must implement this interface – the exam tests the interface name and required callback methods.
- Tip 4: Study when External Objects (Salesforce Connect) is the correct answer for accessing historical external data without storage. When an exam question includes “do not store the data,” “large external historical data,” or “read-only reference,” External Objects is typically correct.
- Tip 5: Practice with Cert Empire’s AP-202 exam questions at the reference implementation interface detail level and LWC decorator usage scenarios.
Best Study Resources
- Cert Empire AP-202 exam questions PDF and practice simulator (2026 edition).
- Salesforce B2B Commerce Developer documentation (developer.salesforce.com/docs/commerce).
- Salesforce B2B Commerce for Developers Trailhead modules.
- TrailblazePrep.com AP-202 study guide and practice questions.
- Pass4Success AP-202 community discussion threads for first-hand exam experience reports.
Why Candidates Choose Cert Empire for AP-202 Preparation
✔ Four reference implementation interface questions. Our AP-202 questions test CartPriceCalculations, CartShippingCharges, CartInventoryValidation, and CartTaxCalculations by interface name, method signature, and implementation scenario – at the specificity first-hand exam reports confirm.
✔ Checkout flow step reordering questions. We test the next-state attribute mechanism and the CheckoutStep interface for custom child components.
✔ LWC decorator usage questions. Our questions test @api versus @wire versus @salesforce/commerce module usage in commerce component context.
✔ External Objects scenario questions. We present historical data access requirements and test whether External Objects or an alternative approach is correct.
✔ Backed by a full money-back guarantee. If our exam questions do not help you pass, we refund your purchase.
Readiness Check
- A developer needs to integrate a third-party tax calculation service into a B2B Commerce checkout. The service requires the buyer’s delivery address, each cart item’s product type and price, and returns a tax amount for each line item. Identify the reference implementation interface the developer must implement, name the specific method the developer must define within the implementing class, and describe what the CartExtension.CartContext parameter provides access to when the method executes.
- An administrator has built a standard checkout flow with steps in this order: Address → Delivery → Payment → Review. The business requires moving the Payment step to appear between Address and Delivery. A developer is assigned to make this change. Describe specifically which attribute in which component must be modified to reorder the checkout steps, explain why the developer does not need to modify the main checkout flow itself, and identify which metadata record houses this configuration.
- A B2B Commerce developer needs to build a checkout component that conditionally hides the “Pay by Purchase Order” option for orders over $10,000, showing only the credit card option for those orders. The component must read the current cart total and the buyer’s account type. Describe which LWC decorators the developer would use to access the cart total and account information, explain the difference in data access pattern between these decorators, and identify which interface the custom component must implement to participate in the checkout flow lifecycle.
- A developer is writing a CartInventoryValidation implementation that must check real-time inventory from an external warehouse system. The warehouse API occasionally returns a 503 (Service Unavailable) error. Describe how the developer should handle this error inside the reference implementation method, what the method should return to the platform when the external service is unavailable, and how the buyer’s checkout experience should be affected by a recoverable versus a fatal inventory validation error.
- A company has 15 years of archived order history in a legacy ERP system containing 200 million records. Service agents need to view a customer’s historical orders from within Salesforce alongside current Salesforce order records. The company’s IT policy prohibits replicating this data into Salesforce due to storage costs and data governance constraints. Identify the Salesforce feature that enables read-only access to external data without data replication, describe how it appears to the agent user interface, and explain why a standard Apex callout from a trigger or controller would be an inferior solution for this requirement.
FAQ’s
What is the Salesforce AP-202 certification?
AP-202 is the B2B Commerce for Developers Accredited Professional credential from Salesforce. It validates development expertise for customizing Salesforce B2B Commerce storefronts using Apex, Lightning Web Components, the B2B Commerce extensibility framework, and the Commerce Connect API. It covers six domains: Checkout Flow Development, Reference Implementations, Basic LWC Development, Advanced LWC Development, Data Management, and Error Handling and Diagnostics.
How many questions are on the AP-202 exam?
60 multiple-choice questions with a 65% passing score (approximately 39 of 60 correct). The exam costs $200 and is delivered through the Salesforce certification portal.
What are the four B2B Commerce reference implementations?
CartPriceCalculations (custom pricing logic at the cart level), CartShippingCharges (shipping rate calculation from external carriers), CartInventoryValidation (product availability checking before checkout proceeds), and CartTaxCalculations (tax amount calculation by integrating external tax services). Each is an Apex class that implements a specific platform interface and requires implementing a defined method that the checkout flow calls at the appropriate stage.
What is the CartTaxCalculations reference implementation used for?
CartTaxCalculations integrates an external tax calculation service into the checkout process. The platform calls the implementation’s calculate method when the buyer reaches the order review step, passing cart item data and delivery address information through a CartExtension.CartContext parameter. The implementation calls the tax service and returns calculated tax amounts that the checkout flow applies to the order.
How does a developer reorder checkout flow steps in B2B Commerce?
By adjusting the next-state attribute in the configuration of the preceding subflow. Each checkout subflow has a next-state attribute that specifies which subflow runs after it completes. Changing this attribute redirects the flow sequence without modifying the main checkout flow structure. This is a configuration change in the subflow metadata, not a Flow Builder canvas change on the main flow.
What interface must a custom child checkout component implement?
Custom LWC components that participate in the checkout flow as child components must implement the CheckoutStep interface. This interface requires implementing specific callback methods that the checkout flow uses to validate the step and determine whether the buyer can proceed to the next step.
What is the Commerce Connect API (Connect in Apex)?
Connect in Apex is a framework that provides programmatic access to storefront operations from Apex classes. It allows developers to read and modify cart state, create orders, and access product and pricing data from server-side Apex code. It is the appropriate mechanism for custom checkout logic that needs to interact with commerce data programmatically rather than through standard DML.
When should a developer use External Objects instead of a standard Apex callout for external data?
External Objects (via Salesforce Connect) are the correct choice when external data must be accessible within Salesforce in a read-only, declarative manner without storage cost – particularly for large historical data sets (archived orders, usage records, billing history) where replication into Salesforce is prohibited by storage or governance constraints. External Objects appear as virtual Salesforce records without being stored in the org. Standard Apex callouts are appropriate for write operations, real-time transactional integrations, or situations where the external data must be processed rather than simply displayed.
Is AP-202 appropriate for Salesforce administrators without development experience?
No. AP-202 requires hands-on Apex and LWC development experience. The exam tests Apex class implementation (interface classes, method signatures, input parameters), LWC decorator usage (@api, @wire), and SOQL queries across the B2B Commerce data model. Candidates without development backgrounds should pursue AP-201 (the administrator credential) instead.
Related Certifications Worth Exploring
AP-202 certified developers expanding their Salesforce Commerce credential portfolio will find our Salesforce CCD-102 (B2C Commerce Developer) exam questions page covers the closely related developer credential focused on Commerce Cloud development, storefront customization, SFRA, integrations, data models, and deployment workflows that complement AP-202 B2B Commerce development expertise . For those building broader Salesforce platform development credentials alongside B2B Commerce specialization, our Salesforce Platform Developer I exam questions page covers the core Salesforce development credential whose Apex, SOQL, and LWC foundation AP-202 builds directly upon – the credential that most AP-202 candidates should hold or be preparing for simultaneously.
Reviews
There are no reviews yet.