Salesforce B2C Commerce Architect Exam Guide | SFCC Architecture & Multi-Site Design

Salesforce Architect • Commerce Credential

Salesforce B2C Commerce Architect Exam Guide

Design global, high-scale B2C Commerce solutions on Salesforce. This guide walks through the Salesforce Certified B2C Commerce Architect exam – architecture topics, domains, study strategy and scenario-style practice questions for Salesforce B2C Commerce Cloud (SFCC).

Who is the B2C Commerce Architect Certification For?

The B2C Commerce Architect exam is aimed at senior developers, technical leads and architects who design and oversee Salesforce Commerce Cloud Digital (SFCC) implementations. You’re a good fit if you:

• Lead B2C Commerce projects with SFRA, cartridges and integrations.
• Design multi-site, multi-region storefronts for brands and franchises.
• Own decisions around performance, caching, security and scalability.
• Collaborate with marketing, merchandisers and operations teams to keep sites running smoothly.

This credential builds on hands-on developer experience and often follows the B2C Commerce Developer certification.

Exam Overview

📊 Exam at a Glance

Exam Name	Salesforce Certified B2C Commerce Architect
Format	Proctored, multiple-choice / multiple-select, architecture-focused
Duration	105 minutes
Number of Questions	~60 scored questions (+ a few unscored items)
Passing Score	Around mid-60s% (check latest Salesforce exam guide for exact value)
Registration Fee	$400 USD (Retake: $200 USD)
Recommended Background	2–3+ years of Salesforce B2C Commerce delivery experience, including at least one multi-site or high-traffic implementation, plus strong SFRA and integration skills.

🧠 What this Exam Focuses On

Questions test whether you can architect:

• Multi-site, multi-locale Commerce Cloud solutions.
• Integrations with ERP, OMS, payment, tax, search and marketing systems.
• Performance, caching, scalability and resiliency patterns.
• Security, compliance, governance and operational readiness.
• Standard SFCC features vs. customization and extension strategies.

SFCC Architecture SFRA Multi-Site Integrations Performance

B2C Commerce Architect Domains

Salesforce occasionally refines domain names and percentages. Treat this as a practical breakdown and confirm details with the latest official exam outline.

🔍 View High-Level Domains & Concepts

• Architecture & Multi-Site Design – Site structure, locale handling, sharing of catalogs, promotions, content and configurations across brands and regions.
• Integrations & Data Flows – Integrating with ERP, OMS, payment, tax, search, marketing and analytics systems using OCAPI, jobs, middleware and events.
• Performance, Caching & Scalability – Page cache, partial cache, CDN strategies, jobs, code design and configuration choices for high-traffic events (launches, Black Friday).
• Security, Compliance & Operations – Security controls, PCI, PII handling, incident response, deployment strategies and monitoring.
• Governance, Extensibility & Best Practices – Cartridge strategy, extensibility patterns, configuration vs customization and long-term maintainability.

The exam is less about writing code and more about choosing the right architecture given constraints such as traffic, complexity, budgets and organizational maturity.

🆕 Recent Themes (High-Level)

• More emphasis on headless and composable storefront options.
• Patterns for integrating Commerce with Service, Marketing and Data Cloud.
• Operational readiness for peak events (sales campaigns, product launches).
• Stronger focus on security, PCI and protecting shopper data.

Key Design Areas for B2C Commerce Architects

🌐 Site & Multi-Site Architecture

• Decide when to use single vs multiple sites vs multiple instances.
• Share catalogs, price books, promotions and content across brands or regions.
• Design for localization (language, currency, tax rules, content).
• Plan rollout strategies for new regions and brands with minimal duplication.

🧱 SFRA & Extensibility

• Use SFRA as the base storefront architecture and extend using cartridges.
• Balance configuration vs customization and avoid heavy core modifications.
• Define a cartridge strategy for shared and site-specific functionality.
• Ensure upgradeability and maintainability across releases.

🔗 Integrations & Data Flows

• Integrate Commerce with OMS/ERP for orders, inventory and pricing.
• Use OCAPI, jobs and middleware for batch and near real-time integrations.
• Connect with payment gateways, tax providers, search services and fraud tools.
• Design error handling, retries and monitoring for critical integrations.

🚀 Performance, Caching & Scalability

• Configure page cache, partial cache and CDN effectively.
• Plan for peak events with load testing and capacity planning.
• Optimize jobs, pipelines and code to reduce load and latency.
• Use asynchronous processing for heavy operations where appropriate.

🛡️ Security, Compliance & Operations

• Design for PCI-DSS and secure handling of payment details.
• Protect PII and account data with strong security configurations.
• Implement deployment pipelines, release strategies and rollback plans.
• Set up monitoring, logging and incident management with clear SLAs.

Where B2C Commerce Architect Fits in Your Journey

While Salesforce doesn’t enforce a strict pre-requisite path, many architects follow something like:

• 1️⃣ Foundation: Web dev background (JavaScript, web architecture, APIs).
• 2️⃣ SFCC Skills: B2C Commerce Developer & real SFRA implementation experience.
• 3️⃣ Integrations & Ops: Experience integrating Commerce with ERP/OMS, payments, tax and operating live sites.
• 4️⃣ Architecture Role: Lead multi-site, global or high-traffic SFCC programs.
• 5️⃣ Exam: Attempt B2C Commerce Architect once you are comfortable making platform-wide decisions.

This credential validates that you can own the technical direction of Commerce Cloud programs, not just implement individual features.

4-Week Study Plan (Adjust for Your Experience)

This plan assumes you already work on SFCC projects. If you’re newer to Commerce, extend each week and add more hands-on labs.

Week 1 – Understand the Exam & Current Architecture

• Read the official B2C Commerce Architect exam guide end-to-end.
• Review your current projects and map out sites, locales, catalogs and key integrations.
• Study reference architectures for multi-site and multi-region SFCC implementations.
• Identify gaps (e.g. PCI, CDN strategy, advanced caching) to focus on in later weeks.

Week 2 – SFRA, Multi-Site & Integrations

• Deep dive on SFRA architecture, controllers, templates and extension patterns.
• Design at least two multi-site models (by brand and by geography) including shared components.
• Map end-to-end integrations with ERP/OMS, payment, search and tax for a sample client.
• Review OCAPI usage and batch/job-based integration scenarios.

Week 3 – Performance, Caching & Operations

• Review page cache, partial cache and CDN configuration options.
• Plan for peak traffic events with capacity, load testing and code review.
• Document an operations runbook – monitoring, alerts, incident response and rollback.
• Evaluate CI/CD options and rollout patterns for zero/minimal downtime deployments.

Week 4 – Security, Scenarios & Mock Exams

• Review PCI, PII protection and security architecture for SFCC.
• Practice answering long scenarios focusing on trade-offs and justification.
• Create 2–3 “reference architectures” (e.g. global retailer, D2C brand, marketplace-style model).
• Take timed practice exams or question sets to simulate the exam pressure.

Sample Scenario-Style Questions

Question 1

A global sportswear brand plans to launch separate storefronts for North America, Europe and Asia-Pacific. They want to share most of the catalog and promotions globally, but support local currencies, taxes and regional marketing campaigns. Which high-level approach should the architect recommend?

1. Create completely independent SFCC instances for each region with no shared components.
2. Use a multi-site architecture in a single SFCC instance, sharing catalogs and core cartridges, while configuring site-specific currencies, tax, content and campaigns.
3. Use a single global site and display different prices through client-side JavaScript based on IP.
4. Host all regional storefronts outside SFCC and only use SFCC as a product feed.

Correct Answer: B

A multi-site architecture on a single SFCC instance supports shared assets plus regional configuration. This aligns with common patterns for global brands and keeps governance manageable.

Question 2

A retailer experiences slow page loads during peak traffic even though product detail pages are properly cached. Analysis shows performance issues with the cart and checkout experience. What is the most appropriate recommendation?

1. Enable full page caching for cart and checkout pages to avoid server processing.
2. Review and optimize the custom code, external service calls and data lookups used in cart and checkout, as these flows have limited caching; use asynchronous calls where appropriate.
3. Disable promotions during peak hours to reduce calculations.
4. Move checkout to a separate platform and call SFCC only after the order is placed.

Correct Answer: B

Cart and checkout usually have limited caching. Performance depends heavily on code quality and integration patterns. The architect should first optimize the implementation and external calls.

Question 3

A brand wants to integrate SFCC with a third-party OMS for order creation and updates. Orders must be transferred reliably, and the OMS will send shipment and cancellation updates back. What pattern should the architect prioritize?

1. Real-time synchronous calls from SFCC to the OMS at every cart update.
2. A job-based or middleware-led asynchronous integration for order export from SFCC, with OMS sending updates back via APIs or message queues, including retry and error-handling mechanisms.
3. Manual export of orders as CSV from SFCC and upload into the OMS daily.
4. Storing orders only in SFCC and not in the OMS to avoid integration complexity.

Correct Answer: B

OMS integrations are typically asynchronous, using jobs or middleware, with robust error handling and retries. This pattern balances reliability, performance and decoupling between systems.

Tip: When answering questions, think like a long-term platform owner – prioritize stability, maintainability and global rollout over short-term quick wins.