New to this track? Our Salesforce Certified Platform Developer exam prep is the recommended first step. See our certification path to understand where this certification fits. The Salesforce Certified B2C Commerce Developer exam weights Application Development most heavily (53%), see the full breakdown, study tips, and practice questions below.
Free practice • No sign-up required
$200 exam • 65% passing score • Free practice
Independent study resource
Exam objectives and policies can change. Confirm current details with the certification issuer.
Check current objectives
Use the official exam guide as the source for current objectives and section weights.
Practice for learning
Use sample questions to review concepts and identify topics for further study.
Works on Any Device
Full practice experience on phone, tablet, or desktop
Free, No Sign-Up
Start practicing immediately, no account or email required
Salesforce Certified B2C Commerce Developer – Complete 2026 Guide
This exam covers full-stack SFCC development: SFRA cartridge architecture, ISML templates, controller scripting, OCAPI/SCAPI integration, and Business Manager configuration. The exam is 60 scored questions in 105 minutes, with a 65% pass mark, weighted towards Application Development (53%) and Data Management Using Business Manager Usage (24%).
Recommended Prerequisites
We recommend completing this certification first to prepare you better.
| Official exam name and code | Salesforce Certified B2C Commerce Developer (B2C Commerce Developer) |
|---|---|
| Questions | 60 |
| Time allotted | 105 min |
| Passing score | 65% |
| Exam fee | $200 |
| Retake fee | $100 |
| Prerequisite certifications | Recommended preparation: Salesforce Certified Platform Developer |
| Study guide release | Summer '26 |
Salesforce Certified B2C Commerce Developer Exam Weightage by Section
1. B2C Commerce Setup (11%)
11%2. Work With a B2C Site (12%)
12%3. Data Management Using Business Manager Usage (24%)
24%4. Application Development (53%)
53%Exam Topics
Last updated:
Who is the B2C Commerce Developer exam for?
- SFCC developers: You build and customize B2C Commerce storefronts using SFRA, ISML, and server-side JavaScript and want the certification to validate your full-stack SFCC skills.
- Full-stack commerce engineers: You work with controllers, templates, OCAPI/SCAPI, and Business Manager configuration and need a credential that covers the entire SFCC development stack.
- Technical leads: You manage cartridge architecture, deployment pipelines, and storefront performance for B2C Commerce projects and want to formalize your technical leadership.
Exam Fees & Registration
Exam Fee
$200
One-time registration fee
Retake Fee
$100
If you need to retake the exam
Comparing certs? View all Salesforce exam fees in one place →
Certification Validity
Maintenance and renewal requirements vary. Check the issuer’s current credential page for requirements that apply to you.
How to Register
Check current Salesforce Certified B2C Commerce Developer (CRT-500) credential and registration details with the issuer.
View official credential detailsOfficial references: Use the issuer’s current materials to confirm exam objectives, format, and fees before booking.
Official sources: Salesforce exam pricing·Independent exam-prep resource; details may change.
Exam Tips
- 1B2C Commerce Architecture and Storefront/Scripts are 55%. Know B2C development and customization.
- 2Understand B2C Commerce architecture: storefront, scripts, and APIs.
- 3Know storefront and scripts: ISML, controllers, and script development.
- 4Be ready for "how do you develop X?" questions.
Prerequisites
- •B2C Commerce development experience
- •JavaScript knowledge
Focus Areas
- •B2C Commerce Architecture
- •Storefront and Scripts
- •Data and APIs
- •Testing and Deployment
Study Strategy
Develop B2C Commerce features.
Customize storefront, write scripts, and integrate with APIs.
Align with the exam outline.
Exam Format and First-Attempt Readiness
The Salesforce Certified B2C Commerce Developer exam has 60 questions in 105 min, passing score 65%. Most Salesforce exams test scenario-based decisions. Focus on when to use each feature, not just terms.
- Study Application Development and Data Management Using Business Manager Usage first, together they carry 77% of the exam.
- Do timed question sets. Build pacing and confidence.
- Review why wrong answers are wrong. It improves scenario reasoning.
- Book the exam once your mock scores are steady at 75%+.
Is the B2C Commerce Developer Exam Hard?
Is the B2C Commerce Developer Exam Hard?
The B2C Commerce Developer exam is considered one of the harder Salesforce developer certifications. The 65% passing score is moderate, but the exam covers the full SFCC stack, from SFRA architecture and ISML templates to OCAPI/SCAPI integration and Business Manager configuration, demanding broad and deep hands-on experience.
- 60 multiple-choice questions in 105 minutes.
- 65% passing score: moderate on paper, but the breadth of topics (SFRA, scripting, APIs, data model, deployment) makes it demanding.
- Full-stack depth: questions span server-side controllers, ISML templates, client-side JavaScript, and Business Manager operations, so you cannot skip any layer.
- Hands-on SFRA experience essential: real project experience with SFRA controller development and at least one OCAPI or SCAPI integration is the strongest preparation.
Pass Rate Guidance
Spend time in a B2C Commerce sandbox building custom controllers, overriding SFRA templates, and configuring jobs in Business Manager before booking the exam.
B2C Commerce Developer Exam Format Explained
B2C Commerce Developer Exam Format Explained
The exam is proctored online or in-person. Here is the format:
Total Questions
60 scored questions
Time Limit
105 min
Passing Score
65%
Question Type
Multiple-choice & multiple-select
How Many Questions Are Scenario-Based?
Around 40-50% of questions are scenario-based. Common patterns describe a storefront customization requirement and ask which SFRA pattern, controller method, or API approach meets it. Expect questions on cartridge path resolution, template overrides, and OCAPI resource configuration.
Best Way to Pass on Your First Attempt
- Master the cartridge override pattern: Know how the cartridge path resolves controllers and templates, and when to use server.extend vs. server.replace.
- Build with SFRA hands-on: Create custom controllers, override ISML templates, and work with the dw.* API in a sandbox environment.
- Study OCAPI and SCAPI: Understand the Shop API vs. Data API, how authentication works for headless scenarios, and when to use each API.
- Know Business Manager inside out: Practice configuring site preferences, running jobs, managing code versions, and diagnosing issues using the request log and pipeline profiler.
B2C Commerce Developer: Key Concepts
SFRA Architecture: Cartridges & Override Pattern
SFRA is the Salesforce B2C Commerce reference architecture built on a cartridge system. cartridges are modular packages containing controllers, templates, models, and static assets. The cartridge path (configured in Business Manager) defines override priority, the leftmost cartridge wins. To customize, create a custom cartridge that overrides specific controllers or templates without editing base cartridges. This keeps base cartridge upgrades non-destructive. The `server.extend` and `server.replace` patterns in controllers allow adding before/after steps or completely replacing a route. The developer exam tests the correct use of the override pattern and common mistakes that break cartridge path resolution.
Controllers, Scripts & Server-Side Logic
SFRA controllers are JavaScript modules using the `server` framework. Routes handle GET and POST requests and render templates or return JSON. Middleware functions (authentication, CSRF, consent) can be prepended to any route. Models and helpers contain business logic separated from controllers. `dw.system`, `dw.order`, `dw.catalog`, the Digital SDK, provides access to Commerce Cloud server-side APIs. Custom scripts (`.js` files in `cartridge/scripts/`) encapsulate reusable logic. The exam tests how to add a middleware step to an existing controller route, how to call a custom script from a controller, and common governor limit considerations in server-side scripts.
Templates (ISML) & Client-Side Assets
ISML (Internet Store Markup Language) is the server-side templating language. `<isinclude>` embeds sub-templates. `<isloop>` iterates collections. `<isset>` assigns variables. `<isif>` handles conditionals. Resource bundles (properties files) provide localized strings. Static assets (JS, CSS, images) are organized in `cartridge/static/` and referenced via `URLUtils.staticURL()`. Webpack compiles and bundles client-side JS in SFRA. SASS is compiled to CSS. Client-side JavaScript uses jQuery and Bootstrap in SFRA. The exam tests ISML syntax, how to pass data from controller to template via `pdict`, and how to add a new client-side component.
Jobs, Feeds & Business Manager Configuration
Commerce Cloud Jobs run server-side scripts on a schedule or on-demand. Jobs process product feeds (import/export), order exports, and inventory updates. The Job Framework uses steps configured in Business Manager. IMPEX (Import/Export) handles large data loads via XML or CSV files placed in the IMPEX directory. Site Preferences store admin-configurable settings accessible in code via `dw.system.Site.current.preferences`. Custom Attributes extend standard objects (products, orders, customers) in Business Manager. The exam tests Job configuration, IMPEX file formats, and how to read custom site preferences in controller logic.
Testing, Debugging & Deployment
Commerce Cloud development uses the `sgmf-scripts` (SFRA build tools) and Salesforce Commerce Cloud CLI (`sfcc-ci`) for deployment. Code deployment uploads cartridges to a code version, which is then activated. The Request Log and Custom Log APIs (`dw.system.Logger`) support debugging. The Pipeline Profiler identifies slow controller routes. Functional tests use `mochawesome` reports. Unit testing is done with jest and `dw-api-types` mocks for Digital SDK. The exam tests the deployment sequence (cartridge upload → code version activation), how to write a testable controller with mocked dependencies, and how to diagnose errors using Business Manager logs.
A storefront request hits a Route (controller), which calls Models to fetch/shape data, renders an ISML template, and can be extended by a custom cartridge without ever modifying the base SFRA cartridge.
How to Pass the Salesforce B2C Commerce Developer Exam
The B2C Commerce Developer exam tests hands-on SFCC development: ISML templates, controller development (SFRA), and script development. Focus on the SFRA architecture and how to implement common storefront customizations.
SFRA Architecture
Know the storefront Reference Architecture (SFRA) MVC pattern: Routes (controllers), Models (data layer), Templates (ISML views), and how cartridges layer on top of SFRA using the cartridge path.
Controller Development
Know how to create custom routes (server.get/post/append/prepend/replace), use middleware for authentication/CSRF protection, and how to return JSON responses or render ISML templates from controllers.
ISML Templates
Know ISML syntax: <isset>, <isif>, <isloop>, <isinclude>, <isreplace>, and how to use locale, currency, and content asset tags. Understand how template caching affects dynamic content rendering.
Script Development
Know how to write CommonJS-style scripts in SFCC, use the dw.* API (dw.catalog, dw.order, dw.customer), and how to call web services from scripts using the dw.net.HTTPClient.
Business Manager Configuration
Know key Business Manager configurations: catalog setup, pricebook management, promotion configuration, storefront configuration (site preferences), and how to use the UX Studio for cartridge management.
Is the Salesforce Certified B2C Commerce Developer (CRT-500) Exam Hard?
DifficultyModerate; plan about 4-8 weeks of focused prep.
Book When ReadyScore 75%+ on three timed mocks before scheduling.
Use Practice, Not DumpsOriginal practice questions build skill without risking your credential.
Exam format: 60 questions, 105 min, 65% passing score.
Salesforce Certified B2C Commerce Developer Practice Questions (With Explanations)
Test your knowledge with these 15 sample questions.
Question 1: A developer needs to add a field to the product object that the storefront will display. Where is this defined?
Key takeaway: Custom attributes extend the standard system objects, which is how product data beyond the built-in fields is held.
Show correct answer and explanation
Correct answer: A. In the system object metadata as a custom attribute
Custom attributes extend the standard system objects, which is how product data beyond the built-in fields is held.
- A parallel custom object breaks the relationship to the product.
- Site preferences hold configuration, not product attributes.
- A template renders data; it does not define where the data lives.
Question 2: What is the purpose of the cartridge path?
Key takeaway: The cartridge path is searched in order, so a file in an earlier cartridge overrides the same path in a later one.
Show correct answer and explanation
Correct answer: C. It decides which cartridge's version of a file wins
The cartridge path is searched in order, so a file in an earlier cartridge overrides the same path in a later one. That is the basis of customisation without editing base code.
- Payment configuration is held in site preferences.
- Job order is configured in the job framework.
- Catalogue assignment is separate site configuration.
Question 3: A developer must customise checkout without modifying the base cartridge. What is the correct approach?
Key takeaway: Putting your own version earlier on the cartridge path lets you change behaviour while leaving the base code upgradeable.
Show correct answer and explanation
Correct answer: A. Override the relevant files in a custom cartridge
Putting your own version earlier on the cartridge path lets you change behaviour while leaving the base code upgradeable.
- Wholesale copying inherits the maintenance burden of the entire cartridge.
- Rebuilding checkout discards tested, compliant functionality.
- Editing base code makes every future platform upgrade painful.
Question 4: What does a controller do in a B2C Commerce storefront?
Key takeaway: Controllers receive the request.
Show correct answer and explanation
Correct answer: B. It handles a request and decides what to render
Controllers receive the request. Run the server-side logic and choose the template or JSON response to return.
- Product data lives in the catalogue and system objects.
- Imports are configured as jobs.
- Styling is handled by stylesheets and templates.
Question 5: A developer needs to share logic between two controllers. What is the appropriate structure?
Key takeaway: Shared server-side logic belongs in a module, so there is one implementation for both callers to use.
Show correct answer and explanation
Correct answer: A. A script module that both controllers require
Shared server-side logic belongs in a module, so there is one implementation for both callers to use.
- Templates render output; they are not a place for business logic.
- Duplicated functions drift apart and double the bug surface.
- Custom objects store data rather than executable logic.
Question 6: Why does a developer need to be careful with API quotas on the platform?
Key takeaway: The platform enforces limits on operations such as object queries per request, and breaching them causes warnings and eventually failures.
Show correct answer and explanation
Correct answer: C. Exceeding them degrades or fails the request
The platform enforces limits on operations such as object queries per request, and breaching them causes warnings and eventually failures.
- Catalogue size is a data concern rather than a quota.
- Cache invalidation is configured separately.
- Cartridge count is not governed by API quotas.
Question 7: What is the role of OCAPI or SCAPI in a B2C Commerce implementation?
Key takeaway: These APIs let external applications, including headless front ends and integrations, read and write commerce data.
Show correct answer and explanation
Correct answer: D. Exposing commerce data and operations to external clients
These APIs let external applications, including headless front ends and integrations, read and write commerce data.
- Catalogue import is handled by the job framework and feeds.
- Storefront rendering is done by controllers and templates.
- Business Manager screens are platform functionality.
Question 8: A price must differ for members of a loyalty scheme. What mechanism supports this?
Key takeaway: Customer groups let the platform resolve a different price book for a defined set of shoppers.
Show correct answer and explanation
Correct answer: B. A customer group with its own price book
Customer groups let the platform resolve a different price book for a defined set of shoppers.
- Duplicating the catalogue is unmaintainable.
- A code requires shopper action and is not automatic membership pricing.
- An attribute holds a number but does not make the platform charge it.
Question 9: What should a developer consider when writing a job that processes the full catalogue?
Key takeaway: Large jobs need to process in chunks with checkpoints, or they exhaust resources and fail partway through.
Show correct answer and explanation
Correct answer: B. Chunking the work so it stays within limits
Large jobs need to process in chunks with checkpoints, or they exhaust resources and fail partway through.
- Taking the storefront down for a routine job is not acceptable.
- Row-by-row processing is what fails at catalogue scale.
- Peak trading is the worst time to run heavy batch work.
Question 10: Why is content caching important on a storefront?
Key takeaway: Caching is what allows a storefront to serve high traffic, and getting cache boundaries right is a core performance concern.
Show correct answer and explanation
Correct answer: B. It keeps response times low under real traffic
Caching is what allows a storefront to serve high traffic, and getting cache boundaries right is a core performance concern.
- Caching trades freshness for speed, so it does the opposite of this.
- Quotas still apply to uncached work.
- Aggressive caching makes personalisation harder, not guaranteed.
Question 11: A developer finds personalised content being served from cache to the wrong shoppers. What is the cause?
Key takeaway: Caching a response that depends on who is viewing it, without including that in the cache key, serves one shopper's content to another.
Show correct answer and explanation
Correct answer: C. Personalised output cached without varying on the shopper
Caching a response that depends on who is viewing it, without including that in the cache key, serves one shopper's content to another.
- Quota breaches cause failures rather than cross-contamination.
- A missing attribute would show empty data rather than someone else's.
- Cartridge order affects which code runs, not cache correctness.
Question 12: What distinguishes a storefront catalogue from a master catalogue?
Key takeaway: Products are defined in a master catalogue and then assigned into a storefront catalogue's category structure for navigation.
Show correct answer and explanation
Correct answer: D. One organises products for browsing; the other owns them
Products are defined in a master catalogue and then assigned into a storefront catalogue's category structure for navigation.
- Both are managed through Business Manager.
- Both can hold any product type.
- Locale is handled separately from catalogue structure.
Question 13: A client wants a headless front end calling the commerce platform. What changes for the developer?
Key takeaway: In a headless setup the front end owns presentation and the platform is consumed through its APIs, so server-side templating largely falls away.
Show correct answer and explanation
Correct answer: D. Rendering moves out and the platform serves data
In a headless setup the front end owns presentation and the platform is consumed through its APIs, so server-side templating largely falls away.
- Jobs run independently of how the front end is built.
- Cartridges remain relevant for server-side logic and hooks.
- Object extension works as before.
Question 14: What is the safest way to handle a shopper's payment details in a custom checkout?
Key takeaway: Card data should never touch your application.
Show correct answer and explanation
Correct answer: A. Let the payment provider capture them directly
Card data should never touch your application. The provider's hosted fields or redirect keeps it out of scope and out of your logs.
- Logging payment details is exactly what must never happen.
- Storing card details on a profile is a serious compliance breach.
- Holding card data in session still brings it into scope.
Question 15: Which best describes what a developer is responsible for on a B2C Commerce project?
Key takeaway: The developer builds and customises how the storefront behaves, extends the data model and connects the platform to other systems.
Show correct answer and explanation
Correct answer: C. Storefront behaviour, integrations and data extensions
The developer builds and customises how the storefront behaves, extends the data model and connects the platform to other systems.
- Visual design is usually produced by designers.
- Merchandising is a business user's role in Business Manager.
- Infrastructure is operated by Salesforce.
Get the Full CRT-500 Question Bank
Most candidates book the exam after scoring 75%+ on full mocks.
If you’re planning to test this quarter, aim to complete full mocks at least 10–14 days before your exam date.
Contact us for more information on our full 60-question mock exams and a personalized study plan. Use the contact form.
Request Mock Exams & Study PlanSalesforce Certified B2C Commerce Developer (CRT-500) Exam FAQs
- What is covered on the Salesforce Certified B2C Commerce Developer (CRT-500) exam?
- The Salesforce Certified B2C Commerce Developer (CRT-500) exam (formerly Salesforce Certified B2C Commerce Cloud Developer) covers section-wise weightage as shown above. Use the exam topics and practice questions on this page to align your study with the official outline.
- What is B2C Commerce (formerly Commerce Cloud)?
- B2C Commerce is Salesforce's e-commerce platform for B2C retailers. It enables businesses to create online storefronts, manage products, and process orders.
- What programming languages do I need for B2C Commerce Developer?
- You need JavaScript knowledge for storefront customization, ISML (Commerce Cloud's templating language), and understanding of e-commerce concepts. Java knowledge is also helpful.
- Are there free practice questions for the Salesforce Certified B2C Commerce Developer (CRT-500) exam?
- Yes. This page includes free sample practice questions with explanations. Use them alongside the current official documentation.
- How do I prepare for the Salesforce Certified B2C Commerce Developer (CRT-500) certification?
- Use the exam tips, prerequisites, and study strategy on this Salesforce Certified B2C Commerce Developer (CRT-500) study guide (formerly Salesforce Certified B2C Commerce Cloud Developer). Focus first on the highest-weighted sections, then take the sample practice questions. Schedule the exam when you consistently score well on practice tests.
Next Certifications After Developer
After this certification, common next steps in the developer track:
Honest Cert Breakdown
Difficulty: Hard
4/5SFCC ISML, controllers, pipelines, and cartridge architecture. Very platform-specific, study resources outside official docs are limited.
Salary Range
$105,000–$145,000 / year
US average for certified professionals • Updated Summer '26 • Source: Salesforce Talent Ecosystem
Is it worth it?
Solid for developers in Commerce Cloud shops. Niche market but high demand within it. Pairs well with a general developer cert.
Section Breakdown
Section-by-Section Breakdown
SFRA Architecture & Cartridges
Storefront Reference Architecture (SFRA): MVC pattern in SFCC, cartridge types (storefront, plugin, link), cartridge path order and inheritance. Creating a custom cartridge, extending SFRA controller and template. Cartridge path priority: how SFCC resolves which cartridge's files to use when multiple cartridges override the same file. Base storefront cartridge (app_storefront_base).
ISML Templates & Controllers
ISML (Internet Store Markup Language): template syntax, ISML tags (<isif>, <isloop>, <isinclude>, <ismodule>, <isset>), accessing server-side variables. Controllers: server.get/post/append/prepend for route handling, middleware chain, res.render, req.querystring, pdict. Script includes. Job scheduling and script execution. Logging and debugging in Business Manager.
Commerce API & Business Manager
OCAPI (Open Commerce API): Data API and Shop API endpoints, authentication (client credentials, JWT), rate limits. SCAPI (Salesforce Commerce API): newer REST API replacing OCAPI for headless commerce. Business Manager: site configuration, catalog management, pricing (pricebooks), promotions, shipping methods, payment methods. Content slots and content assets.
Performance & Debugging
Performance best practices: minimising server-side script execution time, caching strategies (page-level, object-level), CDN configuration. Request pipeline analysis. Business Manager logs: error log, custom log, report log. Sandbox Performance Monitor. Code profiling. Common performance anti-patterns: N+1 queries, excessive custom script in templates.
Integration & Order Management
Order Management: order lifecycle (New → Open → Failed → Cancelled → Completed), order export and import. Payment integration: payment gateway configuration, credit card tokenisation, PayPal integration pattern. Tax integration: internal vs external tax calculation. SFCC Job framework: job steps, job types, custom job steps in Script modules. ERP integration patterns for order fulfilment.
8-Week Study Plan
How to Read Scenario Questions
- 1.Cartridge path order is critical: The first cartridge in the path wins when multiple cartridges have the same file. Custom cartridges should be placed before SFRA’s base cartridge (app_storefront_base) in the path. Any question about overriding default behaviour should mention adding a custom cartridge at the front of the path.
- 2.server.append vs server.prepend: Use server.append to add middleware after the default route handler (e.g., add data to an existing response). Use server.prepend to add middleware before (e.g., authentication check). Use server.replace to completely override the route. Know which to use for a given customisation requirement.
- 3.OCAPI Data API for backend, Shop API for storefront: The Data API handles merchant operations (catalog, orders, pricing management) and requires Business Manager OAuth. The Shop API handles shopper operations (browse, cart, checkout) and can use anonymous or JWT-authenticated sessions.
- 4.Jobs for batch operations: Any scenario involving scheduled or batch processing (order export, inventory import, price updates) should use the SFCC Job framework, not ad-hoc API calls. Jobs run in Business Manager and can execute script modules on a schedule.
Readiness Benchmark
Aim for 75%+ on practice exams before scheduling. B2C Commerce Developer is very hands-on, most questions describe a specific development scenario (override a template, extend a controller, configure OCAPI) and test exact implementation knowledge. There is no substitute for hands-on SFRA development experience.
10 Must-Know Concepts
- SFRA cartridge hierarchy: cartridge path, inheritance, base cartridge (app_storefront_base)
- Creating a custom cartridge and adding it to the cartridge path
- ISML syntax: isif, isloop, isset, isinclude, isprint, and when to use each
- Controllers: server.get, server.post, server.append, server.prepend, server.replace
- Middleware chain: how middleware functions execute, next() pattern
- pdict: what it is, how controllers pass data to templates
- OCAPI: Shop API vs Data API, authentication methods, rate limits
- Business Manager: catalog, pricebooks, promotions, content slots
- Job framework: job steps, scheduling, custom Script job steps
- Order lifecycle: New → Open → Failed → Cancelled → Completed, what triggers each transition
Common Questions
- What is the Salesforce B2C Commerce Developer certification?
- The B2C Commerce Developer (formerly Demandware Developer) certification validates skills in developing and customising Salesforce B2C Commerce Cloud (SFCC) storefronts, including SFRA architecture, cartridge development, ISML templates, controllers, Business Manager configuration, and OCAPI integrations. The exam has 60 questions, 90-minute time limit, 65% passing score, and a $200 fee.
- What is SFRA in Salesforce Commerce Cloud?
- SFRA (Storefront Reference Architecture) is the modern recommended storefront framework for Salesforce B2C Commerce Cloud. It follows an MVC pattern: controllers handle routes and business logic, ISML templates handle presentation, and models represent data. SFRA replaced the older SiteGenesis architecture. Customisations are made by creating custom cartridges that override or extend SFRA's base cartridge (app_storefront_base), preserving upgrade compatibility.
- What is a cartridge in B2C Commerce?
- A cartridge is a deployable module in Salesforce B2C Commerce that contains controllers, templates, models, scripts, and static assets. Cartridges are stacked in a cartridge path, when a file is requested, SFCC searches cartridges in path order and uses the first match found. This enables customisation: a custom cartridge placed first in the path overrides SFRA's base cartridge files without modifying the originals, making future upgrades easier.
- What is OCAPI in B2C Commerce?
- OCAPI (Open Commerce API) is the REST API layer for Salesforce B2C Commerce. It has two main API groups: Shop API (for storefront operations: product browsing, cart, checkout, order creation) and Data API (for Business Manager operations: catalog management, pricing, order management). OCAPI is used for headless commerce implementations and third-party integrations. Salesforce is transitioning to SCAPI (Salesforce Commerce API) as the modern replacement for OCAPI.
- What background is needed for B2C Commerce Developer?
- B2C Commerce Developer requires JavaScript development experience (Node.js-style server-side scripting, though SFCC uses its own Rhino-based JavaScript engine). Familiarity with MVC patterns, template languages, and REST APIs is essential. Candidates typically have 1–3 years of B2C Commerce development experience. The exam is not accessible to Salesforce admins without prior commerce development experience.
Where to Go Next
After this certification, consider: Platform Developer II, Platform App Builder, or JavaScript Developer I.
Topic Difficulty Heatmap
Which topics are a gimme vs which ones trap confident candidates. Use this to prioritise your final-week revision. These are our own topic groupings for study planning, not the official exam sections, those and their weightings are in the credential's exam guide.
| Topic | Difficulty | Study Tip |
|---|---|---|
| B2C Commerce Architecture | Hard | Site architecture and cartridge structure. Know the request pipeline. |
| Storefront and Scripts | Trap ⚠ | ISML vs JavaScript controllers vs script, when to use which is frequently tested. |
| Data and APIs | Moderate | OCAPI and Open API, authentication and versioning appear in scenarios. |
| Testing and Deployment | Moderate | Code deployment and sandbox. Know the deployment workflow. |
Difficulty based on analysis of common candidate errors across each exam section.
Put It Into Practice
Free B2C Commerce Developer practice questions covering all 5 exam sections.
Start Free Practice QuestionsTL;DR: What B2C Commerce Developer Tests
- SFRA cartridge development: Cartridge chaining and precedence, extending controllers using server.extend() and server.replace(), customising ISML templates, and the module system (require()). Knowing the SFRA cartridge structure (controllers, models, scripts, templates, static) is fundamental.
- Commerce business logic: Product and catalogue management, promotions and pricing logic, checkout flow customisation, payment integration patterns, and how to work with B2C Commerce APIs (Product, Basket, Order, Customer).
- Business Manager and platform: Site configuration, content management (Content Slots, Page Designer), A/B testing, job scheduling for automation, and integration with external systems via OCAPI (Open Commerce API).
Which Sections Carry the Most Weight
SFRA + Business Logic + Business Manager = 75%. SFRA cartridge architecture is the foundation, master it first.
Scenario Strategy: How to Approach B2C Commerce Developer Questions
Questions describe a storefront customisation requirement and ask which SFRA pattern, controller method, or Business Manager configuration achieves it. Always prefer extending over replacing, the exam rewards the SFRA best practice of extending core functionality without modifying base files.
- For cartridge questions: cartridge path order determines which cartridge version of a file is used. Custom cartridges should appear first in the cartridge path. Use server.extend() to add new middleware steps to an existing route; use server.replace() to completely override a route. Prefer extend over replace to maintain upgrade compatibility.
- For ISML template questions: templates use <isinclude> to include other templates, <isloop> for iteration, and <isif> for conditionals. ISML expressions use ${expression} syntax. Custom templates in your cartridge override base SFRA templates with the same path. Know which file path takes precedence.
- For promotion questions: B2C Commerce promotions are configured in Business Manager with promotion types (product, order, shipping), qualifiers (basket amount, product quantity), and discounts (percent off, fixed price, free shipping). Promotion ordering and exclusivity settings determine which promotions stack. Know the exclusivity rules.
Booking Readiness Benchmark
75%+ on 3 timed full mocks before booking
B2C Commerce Developer is a specialist certification for developers working on Commerce Cloud implementations. Without real SFRA development experience in a B2C Commerce sandbox, the cartridge architecture and controller extension questions are very difficult. Set up a B2C Commerce sandbox and build a custom cartridge before booking.
3 Concepts That Fail Most B2C Commerce Developer Candidates
These are not the hardest topics; they are the ones where candidates are most confidently wrong. Learn the distinction early.
1. Controllers vs Pipelines: SFRA Uses Controllers, Not Pipelines
Salesforce Reference Architecture (SFRA) uses MVC-style Controllers (JavaScript/Node.js). Pipelines are the legacy SiteGenesis architecture. Exam scenarios about new development expect Controller-based answers. Candidates who studied older materials still default to Pipeline answers. Never recommend Pipelines for new SFRA features, use Controllers and middleware.
2. Hooks vs Cartridge Overrides: Extension Without Modification
SFRA extension points include Hooks (event-driven, registered in hooks.json) and Cartridge Overrides (placing a custom cartridge higher in the cartridge path). Hooks allow extending behaviour at defined integration points without modifying base cartridge code. Overrides replace entire files. The exam prefers Hooks for targeted customisation and overrides only when the entire file needs replacement.
3. Business Manager Site Preferences vs Custom Objects: Where to Store Config
Site Preferences store merchant-configurable settings (feature toggles, API keys, display rules) that non-developers can update via Business Manager. Custom Objects store structured data with specific schemas. Candidates use Custom Objects to store configuration data, the exam expects Site Preferences for settings that merchants need to manage without code deployments.
Questions Candidates Ask
- What is the Salesforce B2C Commerce Developer exam format?
- The Salesforce B2C Commerce Developer exam has 60 multiple-choice questions, a 105-minute time limit, a 65% passing score, and a $200 fee ($100 retake). It tests development on Salesforce B2C Commerce (formerly Demandware) using SFRA (Storefront Reference Architecture), cartridges, controllers, ISML templates, and Business Manager configuration.
- What are the highest-weight B2C Commerce Developer exam sections?
- Storefront Development (30%) and Business Logic (25%) together account for 55% of the exam. Understanding SFRA cartridge architecture, extending controllers, customising ISML templates, and implementing product, catalog, and checkout logic are the most heavily tested areas.
- What is SFRA and why is it important for this exam?
- SFRA (Storefront Reference Architecture) is the current Salesforce B2C Commerce development framework, replacing the older SiteGenesis architecture. The exam primarily tests SFRA development: cartridge chaining, controller extension patterns, the require() module system, and how to extend base SFRA functionality without modifying core files.
- What Business Manager knowledge is needed for the B2C Commerce Developer exam?
- Business Manager is the administration UI for B2C Commerce. You need to understand site configuration, catalog management, pricing rules, promotions, content slots, A/B testing setup, and how Business Manager configurations affect storefront behaviour. Configuration decisions in Business Manager often have direct development implications tested in the exam.
- What concepts do most B2C Commerce Developer candidates get wrong?
- The most commonly misunderstood topics for the B2C Commerce Developer exam are: (1) Controllers vs Pipelines: SFRA Uses Controllers, Not Pipelines; (2) Hooks vs Cartridge Overrides: Extension Without Modification; (3) Business Manager Site Preferences vs Custom Objects: Where to Store Config. Candidates are most confidently wrong on these. Learn the distinctions early to avoid losing marks on questions you expect to get right.
- Why do most B2C Commerce Developer candidates fail questions about Controllers vs Pipelines?
- Salesforce Reference Architecture (SFRA) uses MVC-style Controllers (JavaScript/Node.js). Pipelines are the legacy SiteGenesis architecture. Exam scenarios about new development expect Controller-based answers. Candidates who studied older materials still default to Pipeline answers. Never recommend Pipelines for new SFRA features, use Controllers and middleware.
- Why do most B2C Commerce Developer candidates fail questions about Hooks vs Cartridge Overrides?
- SFRA extension points include Hooks (event-driven, registered in hooks.json) and Cartridge Overrides (placing a custom cartridge higher in the cartridge path). Hooks allow extending behaviour at defined integration points without modifying base cartridge code. Overrides replace entire files. The exam prefers Hooks for targeted customisation and overrides only when the entire file needs replacem...
- Why do most B2C Commerce Developer candidates fail questions about Business Manager Site Preferences vs Custom Objects?
- Site Preferences store merchant-configurable settings (feature toggles, API keys, display rules) that non-developers can update via Business Manager. Custom Objects store structured data with specific schemas. Candidates use Custom Objects to store configuration data, the exam expects Site Preferences for settings that merchants need to manage without code deployments.
Related Study Resources
Start B2C Commerce Developer Prep
After this exam, consider Platform Developer II or Platform App Builder next.
Share or cite this study guide
Free to link from a forum post, study repo or article. Copy the Markdown and paste it anywhere.