CCD-102 B2C Commerce Developer with SFRA Exam Topics and Questions
These Salesforce B2C Commerce Developer with SFRA (CCD-102) 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 CCD-102 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 B2C Commerce Developer with SFRA certification exam.
Let's Practice Free Salesforce CCD-102 Questions Aligned with Official Exam Topics
Storefront Reference Architecture sets the baseline for everything else on this exam. Before you can work with cartridges, controllers, or templates, you need to know how a developer environment is actually assembled: how you get into the platform, how your workspace is structured, how the server connection is established, and how cartridges are laid out so the system can find them. Get this wrong and every subsequent topic becomes harder to reason about under exam pressure. β Getting into the...
Storefront Reference Architecture sets the baseline for everything else on this exam. Before you can work with cartridges, controllers, or templates, you need to know how a developer environment is actually assembled: how you get into the platform, how your workspace is structured, how the server connection is established, and how cartridges are laid out so the system can find them. Get this wrong and every subsequent topic becomes harder to reason about under exam pressure.
β Getting into the platform and setting up your workspace
Accessing SFRA means knowing the entry points a B2C Commerce developer actually uses: Business Manager, the UX Studio or VS Code tooling, and the credentials and sandbox configuration that make a connection possible. The exam tests whether you understand the relationship between your local environment and the remote sandbox, not just that a connection exists. When you create a workspace, you are establishing the file structure that maps to the cartridge path the platform reads. Knowing what belongs where, and why, is the kind of detail that separates a correct answer from a plausible-sounding wrong one. Candidates who treat workspace setup as trivial often miss questions that hinge on configuration order or file placement.
β Server connections and cartridge navigation
Generating a server connection requires specific configuration: hostname, code version, and credentials all have to align. The exam can probe any of those details, and a single wrong assumption about defaults will steer you toward a wrong option. Navigating cartridges is the bridge between this topic and the Cartridges topic that follows. You need to understand the directory conventions SFRA uses and how the development tools surface the cartridge hierarchy. Candidates who learn cartridge navigation only at the surface level tend to lose marks on questions that involve locating a specific file type or understanding why a change in one location does or does not affect the storefront. Precision matters here.
How Introduction to SFRA is tested
This topic carries no published weight, so treat it as foundational rather than optional. Items tend to be scenario-based: a developer needs to connect to a sandbox, or a workspace is misconfigured, and you are asked to identify the right step or the source of the problem. The demand is procedural knowledge applied to a specific situation, not recall of a definition. Where candidates lose marks is in confusing the order of setup steps or misremembering which configuration belongs to the server connection versus the workspace itself. Items also reward knowing what SFRA navigation looks like in practice: which directories exist, what they contain, and what the tooling exposes. If you have only read about this and never worked through the setup, the scenario framing will feel unfamiliar and the distractors will look equally plausible. Hands-on familiarity with the setup sequence is the most reliable preparation.
The ITExamsTopics practice test covers every topic on this exam, including the setup and navigation material that candidates often underestimate. Running through the full question bank before your exam date lets you see which areas of SFRA fundamentals you have actually absorbed and which ones only feel familiar.
The question below targets the kind of procedural reasoning this topic demands. Work through it before checking how you did.
Which line of code creates a content slot that can be included on homepage.isml to display on the home page?
Once you understand how a developer environment is assembled, cartridges become the central architectural concept you will be tested on throughout the exam. Every piece of storefront functionality lives inside a cartridge, and the platform resolves conflicts and overrides by reading cartridges in a specific order. How you define cartridge types, structure the cartridge path, and layer plugin and custom cartridges on top of the base determines what actually runs. Misread the path logic and your answers will be wrong...
Once you understand how a developer environment is assembled, cartridges become the central architectural concept you will be tested on throughout the exam. Every piece of storefront functionality lives inside a cartridge, and the platform resolves conflicts and overrides by reading cartridges in a specific order. How you define cartridge types, structure the cartridge path, and layer plugin and custom cartridges on top of the base determines what actually runs. Misread the path logic and your answers will be wrong even when your subject knowledge is sound.
β Cartridge types and the path that connects them
SFRA distinguishes between several cartridge types: the base SFRA cartridge, plugin cartridges that extend it, and custom storefront cartridges where your project-specific code lives. The exam tests whether you can identify which type a cartridge is from its role and its position in the path, not just from its name. The cartridge path is an ordered list, and the platform reads it left to right, taking the first match it finds. That resolution logic is the mechanism behind overriding base functionality without touching the original files. Candidates who understand the path as a static list of names, rather than as a resolution order with real consequences, will consistently pick the wrong option when a question introduces a conflict between two cartridges that define the same resource.
β Plugin cartridges and custom storefront cartridges
Plugin cartridges sit between the base SFRA cartridge and your custom cartridge in the path. They provide opt-in functionality, such as gift certificates or wishlists, that you include only when your project needs it. The exam can ask you to reason about what happens when a plugin cartridge is present versus absent, or when it is placed in the wrong position. Custom storefront cartridges are where project-specific overrides and additions live. Knowing when to override a controller, a template, or a model in the custom cartridge rather than modifying a plugin or base cartridge directly is a practical distinction the exam rewards. Candidates who conflate these layers tend to lose marks on questions about where a change should be made to achieve a given storefront behavior.
How Cartridges is tested
Cartridge questions are among the most scenario-driven on the exam. You will be given a storefront setup and asked to predict the outcome of a path configuration, or to identify the correct place to make a change. Items reward understanding cartridge path resolution as a dynamic process: given this path and these cartridges, what does the platform serve? The trap is treating cartridge type names as sufficient knowledge. Knowing that a plugin cartridge extends SFRA is not enough; you need to know where it must sit in the path relative to the base and custom cartridges, and what breaks if it does not. Candidates also lose marks by assuming that changes to a base cartridge are acceptable when a custom cartridge override is the right approach. The exam consistently rewards the pattern of extending without modifying the source, so any scenario that tempts you to edit a base or plugin cartridge directly should raise a flag.
Working through a large set of varied cartridge questions in the ITExamsTopics practice test helps you spot the specific path-resolution scenarios that keep appearing. Volume matters here because the distractors are often structurally similar, and pattern recognition only develops with repeated exposure.
The question below puts a cartridge path scenario in front of you. Reason through the resolution order before you commit to an answer.
A developer has the following files in template/resources:
account.proierties
weight.unit=kilos
account_en.propierties
weight.unit=stones
account_en_US.propierties
weight.unit= pounds
Using the default locale configuration, what is the current outcome of the page that renders the
account.isml template snippet below when visiting the Sofrefront with the English for Canada(en_CA) locale=
Your parcel weighs 10 ${Resource.msg('weight.unit','account')}
Cartridges define the structure; controllers define what actually happens when a request hits the storefront. This is where server-side JavaScript, middleware, and the B2C Commerce Script API converge, and it is one of the more technically demanding areas of the exam. You need to understand not just how a controller is written but how middleware chains execute, how the Script API is called from within a controller, and how you diagnose a controller that is not behaving as expected. Gaps...
Cartridges define the structure; controllers define what actually happens when a request hits the storefront. This is where server-side JavaScript, middleware, and the B2C Commerce Script API converge, and it is one of the more technically demanding areas of the exam. You need to understand not just how a controller is written but how middleware chains execute, how the Script API is called from within a controller, and how you diagnose a controller that is not behaving as expected. Gaps here show up quickly in scenario questions.
β What controllers are and how to build them
JavaScript controllers in SFRA follow a specific structure: they export named route functions that the server registers, and each route function chains one or more middleware steps. Understanding that structure matters because the exam tests whether you can read a controller definition and predict its behavior, not just whether you know that controllers exist. Creating a controller means knowing the file location, the export pattern, and how the server object is used to define routes. Candidates who have only seen controllers described in outline form tend to struggle with questions that present a partially written controller and ask what is missing or what will fail. The creation mechanics, not the concept, are what earn marks.
β Middleware functions and their execution model
Middleware is the mechanism by which SFRA controllers compose behavior. Each middleware function in a chain receives the request and response objects and calls next to pass control forward. The exam tests the execution order and what happens when next is not called, or when a middleware function terminates the chain early. Defining middleware functions means understanding both the signature and the contract: what each function is responsible for, and how a custom middleware integrates into a chain that may already include base SFRA middleware. Questions in this area often present a chain with a deliberate flaw and ask you to identify the consequence, so reasoning about execution order under pressure is the skill being assessed.
β Debugging and the Script API
Debugging controllers in SFRA involves both the tooling available in the development environment and the logging mechanisms the platform provides. The exam can ask about how you isolate a problem in a controller or script, so knowing the debugging workflow is practical knowledge, not background reading. The B2C Commerce Script API is the set of server-side objects and methods your controllers call to interact with catalog data, sessions, baskets, and other platform resources. You do not need to memorize the entire API, but you do need to know the major namespaces and how to call them correctly from within a controller context. Misusing an API call, such as accessing a property that requires a specific context, is a category of error the exam surfaces in scenario questions.
How Controllers is tested
Controller questions demand code-level reasoning. You will encounter scenarios where a controller or middleware chain is described or partially shown, and you must identify what it does, what is wrong, or what should be added. Items reward knowing the SFRA server module, the route registration pattern, and the middleware execution contract well enough to reason through a specific case. The most common place candidates lose marks is on middleware: assuming that all middleware functions in a chain always execute, or misreading the order in which they run. Debugging questions reward knowing which tools and log outputs are available in a B2C Commerce sandbox environment. Script API questions reward knowing which namespace handles which domain, such as sessions versus catalog versus order data. Broad familiarity with the API surface matters more than deep knowledge of any single class.
The ITExamsTopics practice test lets you work through controller and middleware scenarios under timed conditions, which is important because this material requires active reasoning rather than recall. Timed practice reveals whether you can apply the execution model quickly enough, not just whether you understand it in the abstract.
The question below involves controller or middleware behavior. Trace the execution path carefully before selecting your answer.
Controllers handle request logic; models handle data. In SFRA, models are plain JavaScript objects that wrap Script API data and shape it for the view layer. This topic has only two sub-topics, but do not let the brevity fool you. The exam tests whether you understand the role models play in the MVC separation SFRA enforces, and whether you know how to extend a model correctly without breaking the base behavior. Both sub-topics carry practical weight in scenario questions. How...
Controllers handle request logic; models handle data. In SFRA, models are plain JavaScript objects that wrap Script API data and shape it for the view layer. This topic has only two sub-topics, but do not let the brevity fool you. The exam tests whether you understand the role models play in the MVC separation SFRA enforces, and whether you know how to extend a model correctly without breaking the base behavior. Both sub-topics carry practical weight in scenario questions.
How Models is tested
Model questions tend to be short scenarios: a developer wants to add a property to the data passed to a template, or a base model is returning something unexpected, and you must identify the right approach. Items reward knowing that SFRA models are not class instances in the traditional sense but factory-produced plain objects, and that extending them means decorating or replacing the factory output rather than subclassing. The trap is reaching for an override pattern that works in other frameworks but conflicts with how SFRA actually constructs model objects. Candidates also lose marks by confusing the model layer with the Script API layer: the model wraps API data, it does not replace the API call. Questions that describe a data-shaping problem will consistently reward the answer that works within SFRA's own extension pattern rather than one that bypasses it. Knowing what extending a model looks like in code, not just in principle, is the preparation that pays off here.
Because this topic is narrow, a few poorly understood questions can disproportionately affect your result. The ITExamsTopics practice test lets you check your grasp of models specifically, so you can confirm you are solid here rather than hoping you are.
The question below tests your understanding of how SFRA models work in practice. Think about the extension pattern before you answer.
Models shape the data; ISML templates render it. This topic covers the templating language B2C Commerce uses on the server side, and it reaches into several areas that catch candidates off guard: the tag set, expression syntax, conditional and loop constructs, and the Resource API that handles localization. Template work is where back-end logic and front-end output meet, and the exam tests both the syntax precision and the structural decisions a developer makes when building or modifying a template. β...
Models shape the data; ISML templates render it. This topic covers the templating language B2C Commerce uses on the server side, and it reaches into several areas that catch candidates off guard: the tag set, expression syntax, conditional and loop constructs, and the Resource API that handles localization. Template work is where back-end logic and front-end output meet, and the exam tests both the syntax precision and the structural decisions a developer makes when building or modifying a template.
β ISML tags, expressions, and template reuse
ISML has its own tag vocabulary that sits alongside standard HTML. The exam tests whether you can identify what a specific ISML tag does in a given context, and whether an expression is written correctly. Expressions in ISML follow a particular syntax for accessing variables passed from the controller, and getting that syntax wrong produces a silent failure or an empty output rather than an error message, which is exactly the kind of subtle bug scenario the exam uses. Reusing code in templates is handled through ISML's include and module mechanisms. Knowing when to use each, and what scope the included template inherits, is the practical knowledge the exam rewards. Candidates who think of template reuse as a convenience feature rather than a structural decision tend to pick answers that work in simple cases but break under the conditions the question describes.
β Conditionals, loops, and the Resource API
Conditional statements and loops in ISML have specific syntax and specific rules about what is in scope inside each block. The exam can present a loop construct and ask what it produces, or present a conditional that has a logical error and ask what the storefront renders. These questions require you to read ISML constructs the way a parser would, not the way a reader skimming for intent would. The Resource API and resource bundles are the localization layer: they connect template output to property files that hold locale-specific strings. The exam tests whether you know how a resource key is referenced in a template and how the bundle lookup works. Candidates who have not worked with resource bundles directly often guess at the syntax and lose marks on questions where the key reference format is the only thing distinguishing the options.
How Internet Store Markup Language is tested
ISML questions are syntax-sensitive. The exam presents templates or template fragments and asks you to predict output, identify errors, or choose the correct construct for a given requirement. Items reward reading ISML precisely: a tag attribute in the wrong position, a missing closing tag, or an expression referencing the wrong variable scope will all produce different behaviors, and the exam uses those differences to build distractors. The localization sub-topic is a reliable source of marks for candidates who take it seriously and a reliable source of losses for those who do not. Resource bundle questions reward knowing the exact mechanism for referencing a key, not a general understanding that localization exists. Loops and conditionals are tested through outcome prediction rather than definition recall, so the preparation that works is reading constructs and tracing what they produce, not memorizing tag names in isolation.
ISML syntax questions are the kind that benefit from seeing many variations. The ITExamsTopics practice test gives you coverage across the full range of tag, expression, and localization scenarios, so you encounter the edge cases in practice rather than for the first time in the exam room.
The question below presents an ISML scenario. Read the construct carefully before deciding, because the difference between options is often a single syntactic detail.
Templates control structure; content slots control what merchandisers can change inside that structure without touching code. This topic is narrower than the ones before it, but it sits at the intersection of developer work and Business Manager configuration, which is exactly where exam questions find their complexity. You need to understand both how a slot is created and wired up in code and how it is configured and targeted in Business Manager, because the exam tests both sides. How Content...
Templates control structure; content slots control what merchandisers can change inside that structure without touching code. This topic is narrower than the ones before it, but it sits at the intersection of developer work and Business Manager configuration, which is exactly where exam questions find their complexity. You need to understand both how a slot is created and wired up in code and how it is configured and targeted in Business Manager, because the exam tests both sides.
How Content Slots is tested
Content slot questions typically describe a merchandising requirement and ask how a developer should implement or configure a slot to meet it. Items reward knowing the slot types available in B2C Commerce, the attributes that control scheduling and ranking, and the content link functions that connect slot output to catalog objects or content assets. The trap is answering from a pure developer perspective and missing the Business Manager configuration step, or vice versa. The exam rewards candidates who understand the full lifecycle: slot definition in code, registration in Business Manager, and the content link functions that make dynamic targeting work. Questions about content link functions specifically reward knowing what each function resolves to and when you would use one over another. Candidates who treat content slots as a simple drag-and-drop feature without understanding the underlying configuration model consistently lose marks on the more specific scenario questions.
The ITExamsTopics practice test includes questions that cross the developer and Business Manager configuration boundary, which is where content slot items tend to live. Seeing how that boundary appears in question form is useful preparation that re-reading documentation alone does not provide.
The question below involves a content slot scenario that requires reasoning about both the code and the configuration side. Work through both before answering.
Content slots give merchandisers control over specific regions; Page Designer gives them control over entire pages. This is the most recent major addition to the B2C Commerce toolset, and the exam tests it as a developer concern: how you set up Page Designer, what tasks belong to the developer versus the business user, and how you build custom components that extend the default capability. The developer and business user responsibilities are deliberately interleaved in this topic, and keeping them straight...
Content slots give merchandisers control over specific regions; Page Designer gives them control over entire pages. This is the most recent major addition to the B2C Commerce toolset, and the exam tests it as a developer concern: how you set up Page Designer, what tasks belong to the developer versus the business user, and how you build custom components that extend the default capability. The developer and business user responsibilities are deliberately interleaved in this topic, and keeping them straight is where candidates earn or lose marks.
How Page Designer is tested
Page Designer questions split into two categories: understanding the platform feature itself, and knowing how a developer builds for it. Items in the first category reward knowing what Page Designer enables for business users and what its architectural constraints are. Items in the second category reward knowing how a custom component is structured: the JSON metadata file that defines its attributes, the ISML template that renders it, and how those two pieces connect. The distinction between business tasks and developer tasks is a direct exam target. Candidates who blur those boundaries, attributing a developer configuration step to the business user or the reverse, will find the distractors in this topic very effective. Custom component questions are the most technical: they reward knowing the file structure and the attribute definition format, not just that custom components are possible. If you have only read a high-level description of Page Designer, the component-level questions will feel underspecified and the wrong options will look reasonable.
Page Designer is the newest material on this exam, and the ITExamsTopics practice test covers it alongside every other topic in one purchase. Checking your readiness across the full exam, rather than focusing only on the areas you know least, gives you an accurate picture of where you actually stand before exam day.
The question below focuses on Page Designer, likely at the component or task-boundary level. Think about the developer's specific responsibilities before you commit.
Page Designer handles page-level composition; the Forms Framework handles how data moves from a customer into the platform. This topic is one of the more technically layered areas of the exam because it spans four distinct concerns: object definition, metadata, server-side validation, client-side validation, template construction, and logging. Each layer has its own file type, its own syntax rules, and its own failure modes. Candidates who understand each piece in isolation but not how they connect tend to lose marks...
Page Designer handles page-level composition; the Forms Framework handles how data moves from a customer into the platform. This topic is one of the more technically layered areas of the exam because it spans four distinct concerns: object definition, metadata, server-side validation, client-side validation, template construction, and logging. Each layer has its own file type, its own syntax rules, and its own failure modes. Candidates who understand each piece in isolation but not how they connect tend to lose marks on the scenario questions that cross two or three layers at once.
β Object definitions and the XML metadata file
Custom and system objects define where form data is ultimately stored. The exam tests whether you know the difference between a custom object you define for a project and the system objects the platform provides, and when you would use each. Getting this wrong at the design stage produces answers that are structurally plausible but architecturally wrong. The XML metadata file is the backbone of the form: it declares the fields, their types, their validation constraints, and the form groups that organize them. The exam can present a metadata file with a deliberate error and ask what the consequence is, or it can ask you to choose the correct attribute for a given field requirement. Knowing the metadata schema precisely matters because the distractors in these questions are usually valid XML that simply uses the wrong attribute or the wrong nesting.
β Server-side and client-side validation scripts
Validation in SFRA forms happens at two points. Client-side validation runs in the browser before the form is submitted, giving immediate feedback. Server-side validation runs after submission, where it enforces rules the client cannot be trusted to enforce. The exam tests both, and it tests them separately. Writing a server-side validation script means knowing how the form object is accessed in the controller context, how field values are read, and how errors are attached to the form so the template can surface them. Writing a client-side validation script means knowing how the form HTML is structured and how JavaScript hooks into field events. The most common exam trap is applying server-side logic patterns to a client-side context or vice versa. The two scripts have different execution environments, different access to platform APIs, and different failure consequences.
β The ISML form template and custom logging
Completing an ISML form template means connecting the XML-defined form fields to rendered HTML inputs and wiring up the error display that validation populates. The exam tests whether you know how form field references work inside an ISML template, specifically the syntax for binding a template element to a form field defined in the metadata file. A mismatch between the field name in the XML and the reference in the template produces a silent failure, and the exam uses exactly that scenario to build questions. Custom logging is the mechanism for recording what happens during form processing: which fields were submitted, which validation rules fired, and what the controller did in response. Knowing the logging API and where log output lands in a B2C Commerce sandbox is practical knowledge the exam surfaces in debugging scenarios. Candidates who skip logging on the grounds that it is a minor feature consistently encounter it in questions they cannot confidently answer.
How Forms Framework is tested
Forms Framework questions are almost always scenario-based and multi-layer. A typical item describes a form that is not behaving as expected and asks you to locate the source of the problem across the metadata, the controller, or the template. Items reward tracing data through the full form lifecycle: from field definition in XML, through controller processing, through validation, and into template rendering. The most reliable way to lose marks here is to fix the symptom in the scenario rather than the cause. If a field value is not being stored correctly, the problem could be in the object definition, the metadata type, the controller read, or the template binding, and the exam expects you to distinguish between those. Logging questions reward knowing which logging class and method to use in a specific context. Validation questions reward knowing which layer is responsible for which class of error. Broad familiarity with the full form pipeline, not deep knowledge of any single file, is what the items consistently reward.
The ITExamsTopics practice test covers the full Forms Framework pipeline, including the cross-layer scenarios that are hardest to prepare for by reading alone. Working through those items before your exam reveals whether you can trace a form problem end to end or whether you are only solid on individual pieces.
The question below involves the Forms Framework. Consider which layer of the pipeline the scenario is targeting before you select your answer.
The Forms Framework keeps data flow inside a well-defined pipeline; hooks let you intercept and extend platform behavior at specific points without modifying the code that triggers those points. This topic has two sub-topics and a narrow scope, but the concept is one the exam applies broadly. Understanding what a hook is and how to create a custom one gives you the mental model for answering questions that describe an extension requirement and ask how it should be implemented cleanly...
The Forms Framework keeps data flow inside a well-defined pipeline; hooks let you intercept and extend platform behavior at specific points without modifying the code that triggers those points. This topic has two sub-topics and a narrow scope, but the concept is one the exam applies broadly. Understanding what a hook is and how to create a custom one gives you the mental model for answering questions that describe an extension requirement and ask how it should be implemented cleanly within SFRA conventions.
How Hooks is tested
Hook questions tend to be short and precise. An item will describe a requirement to extend platform behavior at a specific event point and ask how a developer should implement it. Items reward knowing the two-part structure of a hook: the hook definition in the package.json file that registers the hook point and the script module that implements it. Candidates who know that hooks exist but cannot describe the registration mechanism will find the answer options in these questions equally plausible. The trap is confusing the hook pattern with a controller override or a middleware addition. All three are extension mechanisms, but they apply at different points in the request lifecycle, and the exam uses scenarios where only one is appropriate. Custom hook questions reward knowing what the hook script must export and how the platform calls it, not just that custom hooks are possible. If your preparation has been conceptual rather than code-level, the specifics in the answer options will be difficult to evaluate.
Because hooks is a compact topic, a small number of questions can determine whether you walk away with full marks or none. The ITExamsTopics practice test lets you verify your readiness on this topic in isolation, without having to re-read documentation to find out whether your understanding is exam-ready.
The question below turns on the mechanics of how hooks are defined and registered. Think about both parts of the hook structure before committing.
Hooks extend the platform from within; OCAPI opens the platform to the outside. This topic covers the HTTP-based API layer that external systems, mobile applications, and headless storefronts use to interact with B2C Commerce data and operations. The exam tests both the shape of the API and the mechanics of using it: what each API family does, how URLs are constructed, how settings are configured, and how you actually make and inspect a call. Candidates who treat OCAPI as background...
Hooks extend the platform from within; OCAPI opens the platform to the outside. This topic covers the HTTP-based API layer that external systems, mobile applications, and headless storefronts use to interact with B2C Commerce data and operations. The exam tests both the shape of the API and the mechanics of using it: what each API family does, how URLs are constructed, how settings are configured, and how you actually make and inspect a call. Candidates who treat OCAPI as background knowledge rather than a testable system lose marks on questions that demand specifics.
β The three API families and what they expose
OCAPI is divided into three families: Shop API, Data API, and Meta API. Each serves a different caller with a different purpose. The Shop API exposes storefront operations: basket management, product search, order placement, and the session-aware interactions a customer-facing application needs. The Data API exposes administrative and catalog data: the kind of read and write access a back-office integration or a content management system requires. The Meta API describes the OCAPI schema itself, returning information about the resources and operations available in the other two families. The exam tests whether you can match a given integration requirement to the right API family. Candidates who conflate Shop and Data API responsibilities will consistently pick the wrong resource endpoint in scenario questions. The distinction is not cosmetic: the two families have different authentication models and different access controls.
β URL syntax, settings, and the API Explorer
OCAPI URL syntax follows a specific pattern that encodes the API family, the version, the resource, and any path parameters. The exam can present a URL and ask what it targets, or present a requirement and ask which URL structure satisfies it. Getting the version segment or the resource path wrong produces a URL that resolves to a different resource or returns an error, and the exam uses those differences as distractors. Configuring OCAPI settings in Business Manager controls which clients can access which resources and under what conditions. The exam tests whether you know what those settings govern and where they live. The API Explorer is the in-platform tool for inspecting and calling OCAPI resources interactively. Knowing what the Explorer provides and when you would use it over a direct HTTP client is a practical detail the exam surfaces in tooling questions.
β Making an OCAPI call
Making an OCAPI call means assembling the correct HTTP request: the right method, the right URL, the right headers, and the right request body where one is required. The exam tests this at the level of knowing what a valid call looks like and what a malformed one produces. Authentication is part of this: different OCAPI resources require different authentication approaches, and the exam can ask which approach applies to a given scenario. Response handling is also in scope: knowing what a successful response contains and how an error response is structured is the kind of detail that distinguishes a candidate who has actually made OCAPI calls from one who has only read about them. Questions in this area reward precision about the request structure rather than general awareness that OCAPI uses HTTP.
How Open Commerce API (OCAPI) is tested
OCAPI questions are split between conceptual matching and technical precision. Conceptual questions ask you to identify which API family or resource type fits an integration requirement. Technical questions ask you to evaluate a URL, a configuration setting, or a call structure and identify whether it is correct or what it produces. Items reward knowing the API families as functionally distinct, not just nominally different. The most common source of lost marks is treating Shop API and Data API as interchangeable based on a surface reading of what they access. Configuration questions reward knowing which Business Manager settings control OCAPI access and what each setting does. Call-construction questions reward knowing the HTTP request anatomy for a valid OCAPI interaction. Candidates who have used the API Explorer and made actual calls will find the technical questions much more tractable than those who have only read the documentation. Practical familiarity with the request-response cycle is the preparation that transfers directly to exam performance.
The ITExamsTopics practice test covers OCAPI across all three API families and the full range of configuration and call-construction scenarios. Running through the question bank gives you a map of which OCAPI areas you have genuinely absorbed and which ones you have only skimmed.
The question below involves an OCAPI scenario. Identify which API family or call component is in focus before you evaluate the options.
OCAPI handles real-time external interactions; jobs handle scheduled, batch, and automated server-side processing. In B2C Commerce, jobs are the mechanism for running background tasks: data imports, order processing, feed generation, and anything else that needs to execute on a schedule or on demand outside the storefront request cycle. The exam tests the full job construction process, from defining a flow through configuring steps and parameters to creating a job that actually runs. β Flows, steps, and the job structure A...
OCAPI handles real-time external interactions; jobs handle scheduled, batch, and automated server-side processing. In B2C Commerce, jobs are the mechanism for running background tasks: data imports, order processing, feed generation, and anything else that needs to execute on a schedule or on demand outside the storefront request cycle. The exam tests the full job construction process, from defining a flow through configuring steps and parameters to creating a job that actually runs.
β Flows, steps, and the job structure
A job in B2C Commerce is organized as a flow containing one or more steps. The flow defines the execution sequence and the conditions under which steps run or are skipped. The exam tests whether you understand the relationship between flows and steps as a structural matter, not just a naming convention. Each step in a flow corresponds to a unit of work: a script that performs a specific operation, a service call, or a platform-provided function. Defining job flows means knowing how steps are chained, what happens when a step fails, and how the job reports its outcome. Outlining job steps means knowing what a step definition includes: the script reference, the execution context, and the error-handling behavior. Candidates who think of a job as a single script rather than a structured flow of discrete steps will misread questions about step-level configuration.
β Parameters and job creation
Job parameters are the mechanism for making a job configurable without modifying its code. A parameter can control which site a job runs against, which data set it processes, or which output format it produces. The exam tests whether you know how parameters are declared in a job definition and how they are accessed inside a job script. Getting the parameter access pattern wrong produces a job that runs without error but ignores its configuration, which is exactly the kind of subtle failure the exam uses in scenario questions. Creating a job means knowing where job definitions live in the Business Manager configuration and what the creation workflow requires. Candidates who have only scripted job logic without going through the full creation and scheduling process in Business Manager tend to miss questions about the configuration side of job setup.
How Jobs is tested
Job questions are scenario-driven and often describe a batch processing requirement, then ask how it should be implemented. Items reward understanding the flow-and-step model as the organizing principle for any job, regardless of what it does. The trap is jumping to the script logic before resolving the structural question: what the flow contains, how many steps it needs, and what each step is responsible for. Parameter questions reward knowing the declaration and access pattern precisely enough to evaluate whether a given implementation would work. Creation questions reward knowing the Business Manager workflow, including where job definitions are managed and how scheduling is configured. Candidates who lose marks here are usually those who have strong scripting knowledge but have not worked through the job setup process in Business Manager end to end. The exam treats both the code side and the configuration side as equally in scope.
Jobs questions span scripting and Business Manager configuration, and the ITExamsTopics practice test covers both angles. Working through the full set of job-related items shows you whether your knowledge of the configuration side matches your knowledge of the code side, which is where gaps most often appear.
The question below presents a job-related scenario. Determine whether it is testing the structural model, the parameter pattern, or the creation workflow before you answer.
Jobs run processes in the background; site maintenance determines how well the storefront performs for everyone in the foreground. This topic covers two areas that are easy to underestimate: caching, which directly controls how the platform serves pages and how quickly a storefront responds under load, and performance assessment, which is how you identify where that response time is being lost. Both sub-topics have a practical, diagnostic character, and the exam tests them at the level of applied decision-making rather...
Jobs run processes in the background; site maintenance determines how well the storefront performs for everyone in the foreground. This topic covers two areas that are easy to underestimate: caching, which directly controls how the platform serves pages and how quickly a storefront responds under load, and performance assessment, which is how you identify where that response time is being lost. Both sub-topics have a practical, diagnostic character, and the exam tests them at the level of applied decision-making rather than definition recall.
How Site Maintenance is tested
Site maintenance questions present a performance or caching scenario and ask you to identify the right configuration or diagnostic step. Caching items reward knowing the cache levels available in B2C Commerce, what each level controls, and how cache invalidation is triggered. The exam does not ask you to define caching in the abstract; it asks you to reason about what happens when a specific cache setting is applied to a specific type of page or content. Getting the cache level wrong in a scenario produces an answer that sounds reasonable but misidentifies which layer is responsible for the observed behavior. Performance assessment items reward knowing which tools and metrics are available in a B2C Commerce environment for measuring storefront response time and identifying bottlenecks. Candidates who treat this sub-topic as general web performance knowledge rather than platform-specific tooling knowledge will find the options harder to distinguish. Both sub-topics reward applied familiarity over theoretical understanding, so preparation that involves reasoning through specific scenarios is more effective than re-reading documentation.
Site maintenance is a topic where the exam tests application rather than recall, and seeing how that plays out in question form is the most efficient preparation. The ITExamsTopics practice test gives you a set of caching and performance scenarios to work through so the format is familiar before exam day.
The question below targets caching or performance assessment in a specific B2C Commerce context. Identify which layer or tool the scenario involves before selecting your answer.
Performance and maintenance keep the storefront running well in production; the tools in this topic keep the codebase manageable during development. GitHub, NPM, and the SFRA testing framework are the three pillars here. Each one is testable in its own right, but the exam also tests how they fit together in a development workflow. Candidates who use these tools daily sometimes underperform on this topic because they know their own workflow rather than the canonical SFRA workflow the exam references....
Performance and maintenance keep the storefront running well in production; the tools in this topic keep the codebase manageable during development. GitHub, NPM, and the SFRA testing framework are the three pillars here. Each one is testable in its own right, but the exam also tests how they fit together in a development workflow. Candidates who use these tools daily sometimes underperform on this topic because they know their own workflow rather than the canonical SFRA workflow the exam references.
How Storefront Reference Architecture Tools is tested
Tool questions are a mix of conceptual and procedural. GitHub questions reward knowing how version control fits into an SFRA project: branching conventions, how cartridge code is managed in a repository, and what a developer does to bring SFRA base code into a project. The exam is not testing general Git knowledge; it is testing how Git is applied in a B2C Commerce development context specifically. NPM questions reward knowing which tools the SFRA build pipeline uses and what each one does: compiling SCSS, bundling client-side JavaScript, and running the build process that produces deployable cartridge assets. Candidates who know NPM in general but have not worked with the SFRA-specific scripts and configuration will find the distractors in these questions well-constructed. Testing questions reward knowing the distinction between functional tests and unit tests in SFRA: what each type covers, what framework each uses, and what a test file for each looks like. Items reward knowing which type of test is appropriate for a given scenario, not just that both types exist.
The ITExamsTopics practice test covers the tooling topic alongside every other area on the exam in a single timed session. Practicing under time pressure is particularly useful here because tool questions can feel quick to answer, and that speed can lead to careless errors on the details that actually distinguish the options.
The question below involves one of the SFRA development tools. Consider whether the scenario is about version control, the build pipeline, or the testing framework before you decide.
Every topic on this exam sits on top of the platform and architectural foundation covered here. This is the orientation topic: what B2C Commerce is as a platform, what SFRA is as an architectural choice within it, and how Business Manager is organized as the administrative environment where configuration, merchandising, and operations converge. Candidates often move through this material quickly because it feels conceptual, but the exam finds its questions in the details of how the platform is structured, not...
Every topic on this exam sits on top of the platform and architectural foundation covered here. This is the orientation topic: what B2C Commerce is as a platform, what SFRA is as an architectural choice within it, and how Business Manager is organized as the administrative environment where configuration, merchandising, and operations converge. Candidates often move through this material quickly because it feels conceptual, but the exam finds its questions in the details of how the platform is structured, not in the broad strokes.
How Introduction to Salesforce B2C Commerce is tested
Questions on this topic tend to be definitional in form but precise in target. An item will describe a B2C Commerce capability or organizational concept and ask you to identify what it is, what it does, or where it belongs in the platform hierarchy. Items reward knowing how B2C Commerce is organized at the platform level: the relationship between the organization, the realm, and the site, and how Business Manager surfaces those layers. Candidates who know what Business Manager looks like but have not thought carefully about its organizational model will encounter distractors that reference real features in the wrong structural relationship. SFRA definition questions reward knowing what SFRA is as an architectural pattern and what it replaced, because the exam can ask you to distinguish SFRA from other Salesforce Commerce development approaches. The most reliable way to lose marks on this topic is to treat it as background reading and skip the configuration and organizational details in favor of the higher-level narrative. Those details are exactly what the items test.
This topic anchors the conceptual foundation the rest of the exam builds on. The ITExamsTopics PDF format lets you review the platform and Business Manager organizational material at your own pace, alongside the full question bank, so you can confirm your foundational understanding before focusing on the more technical topics.
The question below tests your understanding of the B2C Commerce platform structure or Business Manager organization. Think about the specific relationships involved before you answer.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full CCD-102 Exam Questions π