Salesforce Certified B2C Commerce Architect (Arch-303) Exam Topics and Questions
These Salesforce Certified B2C Commerce Architect (Arch-303) 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 Salesforce Certified B2C Commerce Architect (Arch-303) 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 Certified B2C Commerce Architect certification exam.
Let's Practice Free Salesforce Certified B2C Commerce Architect (Arch-303) Questions Aligned with Official Exam Topics
Design/Discovery is the largest single slice of this exam, and it is where architects either prove their seniority or expose a gap. The domain tests your ability to translate messy business requirements into a coherent B2C Commerce architecture before a line of code is written. You are expected to choose the right site topology, data model, and cartridge strategy for a given scenario, and to justify those choices against constraints like performance targets, multi-locale requirements, and organisational readiness. Weak preparation...
Design/Discovery is the largest single slice of this exam, and it is where architects either prove their seniority or expose a gap. The domain tests your ability to translate messy business requirements into a coherent B2C Commerce architecture before a line of code is written. You are expected to choose the right site topology, data model, and cartridge strategy for a given scenario, and to justify those choices against constraints like performance targets, multi-locale requirements, and organisational readiness. Weak preparation here is expensive: nearly three in ten marks sit in this area.
The items are scenario-heavy. A client description arrives with competing priorities, partial information, and at least one implied constraint that will steer the architecture if you catch it. What the exam rewards is the ability to read the scenario, identify the binding constraint, and select the architecture that resolves it cleanly. Candidates who have memorised B2C Commerce features without practising applied design decisions find that the options all look plausible, and that is exactly where marks are lost.
Cover site architecture patterns, realm and instance planning, business manager configuration strategy, the role of page designer versus controller cartridges, and the tradeoffs between shared and dedicated infrastructure. Know when a multi-site setup requires separate storefronts versus shared catalogs, and understand how localisation, currency, and tax model decisions ripple through the whole design. The discovery phase also includes stakeholder alignment: knowing which questions to ask before committing to an approach is itself examinable.
How Design/Discovery is tested
Items in this area present a business scenario with several plausible architectural directions and ask you to identify the most appropriate one. The trap is that the distractors are architecturally valid in other contexts: a multi-realm setup is correct sometimes, a shared realm is correct other times, and the scenario detail is what separates them. Candidates who answer from general Salesforce knowledge rather than B2C Commerce-specific constraints consistently pick the wrong option.
The exam rewards candidates who can distinguish between what is technically possible and what is architecturally appropriate for the stated requirements. Items also test discovery-phase judgement: given a set of client constraints, which architectural decision must be made first, and which can be deferred. Performance implications of catalog structure, the consequences of storefront inheritance choices, and the scoping of business manager roles all appear at this stage. Spending extra preparation time on site topology and instance planning pays off disproportionately here given the weight of the area.
The ITExamsTopics practice test for this exam covers Design/Discovery questions across a range of scenario types. Working through the full bank lets you spot the specific scenario patterns that recur in this area, which is harder to do from reading alone and essential given how much of the exam this topic represents.
The question below puts a realistic client scenario in front of you and asks you to commit to an architectural direction under the same time pressure you will face on exam day.
A new dent is moving from their existing ecommerce platform to B2C Commerce. They have an existing service that connects to the Email Marketing System. The endpoint of the service can directly parse the data posted by the customer from the Storefront page for marketing materials subscriptions. it if required that theservice implementation on the B2C Commerce site supports authentication and encoding.
What type should the Architect document this new service as?
Once the architecture is settled, Build is where you prove you can turn it into working B2C Commerce implementation decisions. This domain moves from whiteboard to working system: cartridge development patterns, SFRA structure, pipeline and controller conventions, template inheritance, and the correct use of the Script API. The weight is significant, and the questions assume you have actually built on the platform rather than read about it. If your experience sits more on the design or admin side, this is...
Once the architecture is settled, Build is where you prove you can turn it into working B2C Commerce implementation decisions. This domain moves from whiteboard to working system: cartridge development patterns, SFRA structure, pipeline and controller conventions, template inheritance, and the correct use of the Script API. The weight is significant, and the questions assume you have actually built on the platform rather than read about it. If your experience sits more on the design or admin side, this is the area most likely to cost you marks.
The exam does not ask you to write code, but it does ask you to evaluate implementation approaches and identify which one follows B2C Commerce best practices. Knowing why SFRA was introduced, what it changed about cartridge loading order, and where customisation belongs versus where it breaks upgrade paths is the level of depth this domain demands.
How Build is tested
Build items typically describe an implementation goal and ask which approach achieves it correctly within the B2C Commerce framework. The distractors often describe approaches that work in isolation but violate platform conventions: overriding a core cartridge file directly instead of extending it, placing business logic in a template rather than a controller, or using a deprecated pipeline pattern where a controller is expected.
The exam rewards knowing the platform's preferred patterns and being able to identify where a shortcut will cause problems at scale or during an upgrade. SFRA cartridge ordering, the extend and require model, and the boundaries between server-side and client-side responsibility are all fair game. Candidates who have built only on the older pipeline-based architecture and have not updated their mental model to SFRA tend to lose marks by selecting approaches that were valid before but are no longer the recommended path. Timed practice helps here because the scenario details are dense and the differences between options are often subtle.
Running the ITExamsTopics practice test under timed conditions is particularly useful for Build, where the scenario details are dense. Seeing how many items you can answer confidently within the time limit tells you more about your readiness than any re-read of the documentation.
The question below targets a specific Build decision point and reflects the style of implementation-focused item you should expect in this area of the exam.
A business wants to migrate its customerservice provider from provider A to provider B. Provider e offers a LINK cartridge to integrate with its commerce solution.
Which three artifacts need to be created by the Architect? Choose 3 answers
After Build comes the operational reality: things go wrong, and the exam expects you to know how to find out why. Monitoring/Troubleshooting tests your familiarity with the tools B2C Commerce provides for diagnosing problems in a live or staging environment, reading logs, interpreting performance data, and tracing an issue to its source. At 14%, this area is not the largest, but it is one of the most practically specific: you either know where to look in Business Manager and what...
After Build comes the operational reality: things go wrong, and the exam expects you to know how to find out why. Monitoring/Troubleshooting tests your familiarity with the tools B2C Commerce provides for diagnosing problems in a live or staging environment, reading logs, interpreting performance data, and tracing an issue to its source. At 14%, this area is not the largest, but it is one of the most practically specific: you either know where to look in Business Manager and what the output means, or you do not.
Candidates who have spent time in production support tend to find this area straightforward. Those who have only built and handed off tend to underestimate it. The exam tests diagnosis, not just awareness that tools exist.
How Monitoring/Troubleshooting is tested
Items in this area describe a symptom: a storefront error, a degraded response time, a failed job, a payment integration that stops responding under load. You are asked to identify the most appropriate diagnostic step or to select the tool and log source that would surface the root cause fastest.
The exam rewards knowing which Business Manager report or log file is relevant to which class of problem, and understanding what the output of those tools actually indicates. The trap is selecting a plausible-sounding diagnostic action that addresses a symptom rather than the cause, or choosing a tool that exists but is not the right fit for the described scenario. Candidates also lose marks by confusing the scope of different monitoring features: a site-level performance issue and a job execution failure require different investigation paths, and the exam exploits that distinction. Knowing the specific capabilities of the storefront toolkit, the log center, and the performance dashboard is the preparation that pays off in this domain.
The ITExamsTopics practice test lets you check Monitoring/Troubleshooting specifically without sitting through the full exam again. If this is a weak area for you, isolating those questions and tracking your accuracy across attempts is a faster correction than reading documentation from scratch.
The question below presents a diagnostic scenario and asks you to select the response that gets to the root cause, which is exactly the form these items take on the real exam.
Integrations and Customizations carries the second-highest weight in the exam, and it covers the territory where B2C Commerce projects most often succeed or fail in practice. The domain tests your ability to design and evaluate connections between B2C Commerce and external systems: payment providers, OMS, PIM, marketing platforms, and Salesforce's own product ecosystem. It also covers the customisation patterns that keep those integrations maintainable. If Design/Discovery is about what you decide before the project starts, this domain is about how...
Integrations and Customizations carries the second-highest weight in the exam, and it covers the territory where B2C Commerce projects most often succeed or fail in practice. The domain tests your ability to design and evaluate connections between B2C Commerce and external systems: payment providers, OMS, PIM, marketing platforms, and Salesforce's own product ecosystem. It also covers the customisation patterns that keep those integrations maintainable. If Design/Discovery is about what you decide before the project starts, this domain is about how you make it work once it does.
The breadth here is real. You need to understand OCAPI and SCAPI, the job framework for batch integrations, hook-based extensibility, and the tradeoffs between synchronous and asynchronous integration patterns. Knowing which approach fits which scenario is the core skill.
How Integrations and Customizations is tested
Items in this domain present integration requirements and ask you to select the architecture or mechanism that meets them correctly. The distractors are usually valid integration approaches applied to the wrong scenario: using a synchronous API call where an asynchronous job is required, choosing OCAPI where SCAPI is the current recommendation, or applying a custom hook where a standard extension point already exists.
The exam rewards knowing the boundaries between integration patterns and understanding which Salesforce B2C Commerce mechanism is appropriate for a given data volume, timing requirement, or system relationship. Candidates who treat OCAPI and SCAPI as interchangeable, or who are unfamiliar with the job framework's capabilities, consistently lose marks in this area. Customisation questions test whether you know the platform's extension points well enough to avoid overriding core code. The combination of integration breadth and customisation depth makes this domain one where scattered preparation shows up clearly in the score.
Because Integrations and Customizations spans a wide range of mechanisms and patterns, a full question bank gives you coverage that a targeted study session cannot. The ITExamsTopics practice test surfaces the specific combinations of scenario and mechanism that this domain tests, across the full range of integration types.
The question below focuses on an integration decision point and asks you to apply the same pattern-matching the exam demands when requirements and constraints are set against each other.
Launch is the final domain and it tests a different kind of judgement from the earlier ones. Where the previous areas focused on building and connecting the platform, Launch is about safely moving a project from development to production. The domain covers go-live planning, cutover sequencing, DNS and certificate management, performance validation, and the decisions that protect a launch from becoming an incident. At 16%, it carries more weight than Monitoring/Troubleshooting, and candidates who treat it as a formality tend...
Launch is the final domain and it tests a different kind of judgement from the earlier ones. Where the previous areas focused on building and connecting the platform, Launch is about safely moving a project from development to production. The domain covers go-live planning, cutover sequencing, DNS and certificate management, performance validation, and the decisions that protect a launch from becoming an incident. At 16%, it carries more weight than Monitoring/Troubleshooting, and candidates who treat it as a formality tend to be surprised by the specificity of the questions.
The exam expects you to know the sequence of steps that a B2C Commerce go-live requires, the dependencies between them, and what happens when one is skipped or done out of order.
How Launch is tested
Launch items describe a go-live scenario, often with a constraint such as a hard deadline, a data migration requirement, or a cutover window, and ask which action or sequence is most appropriate. The distractors frequently describe steps that are individually correct but placed in the wrong order, or that omit a dependency that would cause a production failure.
The exam rewards understanding the end-to-end launch sequence for a B2C Commerce implementation, including the role of sandbox, staging, and production instances during cutover, the timing of DNS changes relative to SSL certificate provisioning, and the validation steps that must complete before traffic is switched. Candidates also need to know what can be rolled back and what cannot, because launch decisions with irreversible consequences appear as items where the right option is the one that preserves options. Preparation that covers only the technical build phase and skips launch planning leaves marks on the table that are straightforward to recover with focused study.
The ITExamsTopics practice test includes Launch questions drawn from the full range of go-live scenarios this domain covers. Using the free demo before purchasing lets you see the item style and judge how your launch knowledge holds up before committing.
The question below tests launch sequencing and cutover judgement, the two areas where this domain most consistently separates prepared candidates from those who are not.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Salesforce Certified B2C Commerce Architect (Arch-303) Exam Questions 🚀