Career upgrade: Learn practical AI skills for better jobs and higher pay.
Level up
PracticeVideosBlogFlashcardsEspañol
All Practice Exams

100+ Free SF B2C Commerce Arch Practice Questions

Pass your Salesforce Certified B2C Commerce Architect exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately
100+ Questions
100% Free
1 / 100
Question 1
Score: 0/0

In a B2C Commerce Composable Storefront (PWA Kit) implementation, what is Managed Runtime and what deployment capability does it provide?

A
B
C
D
to track
Same family resources

Explore More Salesforce Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

Salesforce Certified Administrator

Practice QuestionsStudy GuideCheat SheetFlashcards1 video2 blogs

Salesforce Agentforce

Practice Questions

Salesforce Certified Advanced Administrator

Practice Questions

Salesforce Platform App Builder

Practice Questions

Salesforce Platform Developer I

Practice Questions

Salesforce Service Cloud Consultant

Practice Questions

More From This Family

Videos and articles for deeper review.

VideoFREE Salesforce Admin Exam Guide 2026: Pass on First TryArticleFREE Salesforce Admin Exam Guide 2026: Pass on First Try28 min readArticleSalesforce Admin Salary & Is It Worth It in 2026? (Free)13 min read
2026 Statistics

Key Facts: SF B2C Commerce Arch Exam

60

Exam Questions

Salesforce official exam guide

105 min

Time Limit

Salesforce official exam guide

64%

Passing Score

Salesforce official exam guide

$400

Exam Fee

Salesforce / Webassessor

5

Exam Domains

Architecture, Catalog, Operations, Code, Integration

1 year

Credential Validity

Annual maintenance required

The B2C Commerce Architect exam is 60 multiple-choice questions in 105 minutes, passing score 64%, administered via Webassessor / Kryterion for $400. Domains: Architecture & Design (25%), Catalog/Customer/Pricing/Cart/Inventory (22%), Site Operations (20%), Custom Code (18%), Integration (15%). Prerequisite: B2C Commerce Developer credential strongly recommended.

Sample SF B2C Commerce Arch Practice Questions

Try these sample questions to test your SF B2C Commerce Arch exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1A B2C Commerce Architect is designing a storefront for a global retailer using SFRA. The client wants a single codebase that can serve 10 regional sites with different languages, currencies, and product catalogs. What is the recommended approach?
A.Create one site per region, each with its own SFRA cartridge stack, sharing a common base cartridge via the cartridge path
B.Create one global site and use the locale setting to switch catalogs and currencies dynamically at runtime
C.Use a single Business Manager instance with one site and override content using custom attributes per locale
D.Deploy separate Salesforce B2C Commerce instances for each regional site to isolate configuration
Explanation: SFRA supports multi-site architectures where each site has its own configuration (locale, currency, catalog) but shares a common base cartridge via the cartridge path. Architects layer site-specific customizations on top of the base cartridge, minimizing duplication while enabling regional flexibility. A single global site cannot cleanly isolate catalog assignments per region.
2A client migrating from a custom legacy storefront to B2C Commerce Composable Storefront (PWA Kit) asks about API access patterns. Which statement correctly describes how the PWA Kit accesses B2C Commerce data?
A.PWA Kit calls OCAPI Shop APIs via REST using ShopperLogin (SLAS) tokens for authenticated access
B.PWA Kit uses ISML templates rendered server-side and delivered through SFRA pipelines
C.PWA Kit connects directly to the B2C Commerce database via JDBC connectors
D.PWA Kit uses SOAP-based Web Services APIs for all storefront data access
Explanation: The Composable Storefront (PWA Kit) is a React-based front end that communicates with B2C Commerce exclusively through Commerce APIs (a subset of OCAPI and newer APIs), using SLAS (Shopper Login and API Access Service) tokens for authentication. It does not use ISML, pipeline-based rendering, or SOAP. This decoupled architecture is the foundation of Composable Storefront.
3During a peak traffic event, a B2C Commerce storefront experiences slow product list pages. The architect identifies that a custom cartridge is calling a complex search refinement query on every page load with no caching. What is the BEST architectural fix?
A.Implement page-level caching in the controller and set an appropriate cache time using PageCacheControllerMixin
B.Move the refinement logic to a client-side JavaScript call that executes after initial page load
C.Increase the B2C Commerce instance quota by contacting Salesforce support
D.Replace the search refinement with hardcoded category IDs in the cartridge
Explanation: B2C Commerce SFRA controllers support server-side page caching. Applying PageCacheControllerMixin (or equivalent cache headers) to a frequently requested, rarely changing page dramatically reduces repeated query execution during traffic spikes. This is the standard performance pattern for B2C Commerce storefronts.
4A fashion retailer needs real-time inventory updates from their ERP during the shopping experience. The architect must choose between OCAPI's inventory endpoint vs a custom integration. Which pattern is MOST appropriate for a high-volume storefront?
A.Use OCAPI to pre-populate B2C Commerce inventory records in batches, then serve inventory reads from B2C Commerce cache — not from the ERP in real time
B.Make a direct ERP API call from the SFRA controller on every product detail page load
C.Call the ERP via a synchronous REST hook embedded in the add-to-cart webhook
D.Disable inventory checking in Business Manager to eliminate the latency
Explanation: Real-time ERP calls on every page load introduce latency and create a hard dependency on ERP availability during peak traffic. The recommended pattern is to use an integration layer (middleware or ETL job) that periodically pushes inventory data into B2C Commerce via OCAPI, allowing the storefront to serve inventory from B2C Commerce's own cached data store. This decouples storefront performance from ERP availability.
5A client wants to extend B2C Commerce checkout with a custom payment provider not available in the LINK marketplace. The architect must add a payment method while maintaining SFRA upgrade compatibility. What is the correct approach?
A.Create a custom SFRA cartridge that overrides only the necessary payment scripts and templates, placed before the base cartridge in the cartridge path
B.Directly edit the base SFRA cartridge files to add the payment provider logic
C.Create a Job script that processes payment asynchronously after order placement
D.Use Business Manager customization rules to reroute payment calls to the new provider
Explanation: SFRA's cartridge path architecture is designed so custom cartridges placed before the base cartridge override only what they need. This preserves upgrade compatibility — when Salesforce releases SFRA updates, the base cartridge can be replaced without losing customizations. Directly editing base cartridge files is the most common SFRA upgrade blocker.
6What is the primary purpose of the SFRA (Storefront Reference Architecture) in Salesforce B2C Commerce?
A.To provide a modular, MVC-based reference implementation that serves as the recommended starting point for custom storefront development
B.To replace all custom JavaScript with declarative Salesforce Flow configurations
C.To provide a no-code drag-and-drop storefront builder managed entirely in Business Manager
D.To enforce a required deployment pipeline that validates all cartridges before production release
Explanation: SFRA is Salesforce B2C Commerce's recommended storefront architecture, providing an MVC-based (Model-View-Controller) reference implementation built on Node.js and ISML. It replaces the older SiteGenesis architecture with a more modular, extensible pattern. Architects use SFRA as the base and layer customizations through the cartridge path system.
7A B2C Commerce storefront uses Einstein Product Recommendations. The client notices recommendations appear on the page 2 seconds after initial render. An architect needs to eliminate this delay. What is the BEST approach?
A.Pre-fetch recommendations server-side during page render and embed them in the initial HTML response
B.Increase the Einstein API timeout setting in Business Manager to 5 seconds
C.Replace Einstein with a static bestseller list that never requires an API call
D.Use a JavaScript setTimeout to delay recommendation rendering until page load completes
Explanation: Server-side pre-fetching of Einstein recommendations during page rendering ensures the data is available when the HTML is delivered to the browser, eliminating the client-side async delay. This approach requires careful caching strategy (recommendations are personalized, so cache by segment or use CDN bypass for logged-in users) but removes the visible loading lag.
8A multi-brand retailer needs separate B2C Commerce storefronts for each brand but wants shared customer accounts and order history across brands. What architecture best supports this requirement?
A.Use a single B2C Commerce realm with multiple sites sharing one customer list, enabling cross-site login and order visibility
B.Deploy separate B2C Commerce realms per brand and use an external identity provider to federate logins
C.Store all customer data in an external CRM and have each site query it via OCAPI on login
D.Create duplicate customer profiles on each site and sync via nightly batch jobs
Explanation: B2C Commerce supports multi-site configurations within a single realm (organization) where multiple sites can share a customer list. This shared customer list enables cross-brand login and unified order history without external federation. The architect configures sites to reference the same customer group/list in Business Manager.
9What is the role of the Open Commerce API (OCAPI) in a Salesforce B2C Commerce architecture?
A.OCAPI provides REST APIs for external systems to read and write B2C Commerce data including products, orders, and customer records
B.OCAPI is the internal rendering engine that converts ISML templates to HTML
C.OCAPI is the Business Manager UI framework for configuring storefront rules
D.OCAPI is a Salesforce-proprietary protocol for connecting B2C Commerce to Salesforce CRM
Explanation: OCAPI (Open Commerce API) is Salesforce B2C Commerce's REST API layer that allows external systems to interact with the platform. It includes Shop APIs (customer-facing storefront operations) and Data APIs (back-end operations for business logic and data management). OCAPI is central to headless commerce and integration architectures.
10A B2C Commerce Architect is designing a promotion engine for a flash sale that starts at midnight. The client expects 50,000 concurrent shoppers. Which pricing and promotion architecture consideration is MOST critical?
A.Pre-warm the promotion cache before the sale starts and ensure promotion indexing is complete so the search results reflect sale prices immediately at launch
B.Configure promotions to apply at order submission to reduce real-time calculation load
C.Use only customer group-based pricing instead of promotions to avoid promotion engine overhead
D.Disable site caching entirely during the flash sale to ensure prices are always current
Explanation: B2C Commerce uses a search index that includes pricing data. If promotion caching and indexing are not pre-warmed before the sale launch, shoppers will see stale prices or experience slow responses as the system catches up. Pre-warming cache and ensuring promotion index builds complete before launch is essential for high-concurrency flash sale events.

About the SF B2C Commerce Arch Exam

The Salesforce Certified B2C Commerce Architect validates expertise in designing scalable, performant, and maintainable B2C Commerce (formerly Demandware) implementations. Architects must demonstrate mastery of SFRA cartridge architecture, headless/composable storefront design, multi-site topology, catalog and pricing engines, OCAPI and Commerce REST APIs, SLAS, and Business Manager operations.

Questions

60 scored questions

Time Limit

105 minutes

Passing Score

64%

Exam Fee

$400 USD (Webassessor / Kryterion)

SF B2C Commerce Arch Exam Content Outline

25%

Architecture and Design

Multi-site architecture, SFRA cartridge hierarchy, headless vs. SFRA decisions, PWA Kit/Managed Runtime, and scalability/NFRs

22%

Catalog, Customer, Pricing, Cart, and Inventory

Catalog configuration, product/variation models, customer groups/segmentation, price books, promotion engine, cart/order lifecycle, inventory models

20%

Site Operations

Business Manager, code versions, jobs and pipelines, site preferences, page designer, content slots, campaigns, A/B testing, replication

18%

Custom Code and Customization

SFRA controllers, ISML templates, client-side JS/SCSS, build tools (webpack/npm), cartridge extension patterns, debugging

15%

Integration

OCAPI Shop and Data APIs, Commerce REST APIs, SLAS OAuth flows, payment gateway integration, OMS/ERP/CRM bridges, service framework

How to Pass the SF B2C Commerce Arch Exam

What You Need to Know

  • Passing score: 64%
  • Exam length: 60 questions
  • Time limit: 105 minutes
  • Exam fee: $400 USD

Keys to Passing

  • Complete 500+ practice questions
  • Score 80%+ consistently before scheduling
  • Focus on highest-weighted sections
  • Use our AI tutor for tough concepts

SF B2C Commerce Arch Study Tips from Top Performers

1Understand when to recommend SFRA vs. Composable Storefront (PWA Kit) — this is the highest-leverage architectural decision question
2Know the cartridge path override chain thoroughly: core → base cartridge → site-specific cartridge
3For integrations, distinguish OCAPI (legacy) from Commerce APIs (new) and always know when SLAS is required
4Practice explaining catalog hierarchy: master catalog → storefront catalog → category → product → variation
5Know all job types (import/export, custom jobs, site import) and replication strategies for production deployments
6For Business Manager, understand code versions — staging, active, and how promotion/content slot scheduling interacts with code versions

Frequently Asked Questions

What is the Salesforce B2C Commerce Architect exam format?

The exam consists of 60 multiple-choice questions completed in 105 minutes. The passing score is 64%. It is administered via Webassessor / Kryterion and can be taken online (remotely proctored) or at a testing center.

How much does the B2C Commerce Architect exam cost?

The exam fee is $400 USD. Retakes are $200 (50% of the original fee). Salesforce periodically offers vouchers through training programs.

What prerequisites are required for the B2C Commerce Architect exam?

There are no hard prerequisites, but the Salesforce Certified B2C Commerce Developer certification is strongly recommended. Candidates should have 3+ years of hands-on B2C Commerce implementation experience including SFRA architecture and Business Manager administration.

What is SFRA and why is it important for the exam?

Storefront Reference Architecture (SFRA) is Salesforce's recommended MVC-based architecture for B2C Commerce storefronts. The architect exam heavily tests cartridge path resolution, controller extension patterns, ISML templates, and when to use headless/composable alternatives versus SFRA.

What is the difference between OCAPI and Commerce APIs?

OCAPI (Open Commerce API) is the legacy REST API for B2C Commerce using SHOP and DATA endpoints. Commerce APIs are the newer, next-generation REST APIs (including Shopper APIs) that pair with SLAS for OAuth 2.0 authentication. The exam tests both, but newer headless architectures prefer Commerce APIs.

What is SLAS and when is it required?

Shopper Login and API Access Service (SLAS) is the OAuth 2.0 authorization server for B2C Commerce headless implementations. It is required for all Composable Storefront / PWA Kit implementations and for any architecture using Commerce APIs with shopper-facing operations.