Free ARC-300 Practice Test Questions and Answers (2026) | Cert Empire Practice Questions

The most efficient and maintainable approach is to leverage B2C Commerce's standard, optimized import framework for complex data objects like promotions and coupons. This makes using the standard import steps for these two tasks the correct choice. For the file retrieval, while a standard SFTP step exists, creating a formal "custom step" is a structured and reusable way to encapsulate the logic for downloading files from a specific external source. This approach correctly separates the file retrieval logic from the core data import processing, which should rely on the platform's native capabilities.

1. Standard vs. Custom Job Steps: The B2C Commerce documentation outlines the use of both standard steps for common tasks and the creation of custom steps for specialized logic. The standard import steps are designed for performance.

Source: Salesforce B2C Commerce Infocenter

"Jobs

" section "Standard and Custom Job Steps." (Specific page varies by documentation version

but the concept is fundamental to the Job Framework).

2. Standard Import Steps: The documentation lists the available standard steps

including those for importing catalog data

promotions

and coupons

which are the preferred method.

Source: Salesforce B2C Commerce Infocenter

"B2C Commerce Standard and Custom Job Steps

" specifically referencing sfcc.step.b2c.dw.catalog.ImportPromotions and sfcc.step.b2c.dw.catalog.ImportCoupons.

3. Creating Custom Job Steps: For logic not covered by standard steps

a custom step type can be created by defining it in a steptypes.xml file and linking it to a script module. This is a more structured approach than using the generic ExecuteScriptModule.

Source: Salesforce B2C Commerce Infocenter

"Creating Custom Job Steps

" section "The steptypes.xml File."

The requirements involve building a homepage with a mix of static and dynamic content that can be scheduled.

Content Slots and Assets (C): This is a foundational B2C Commerce feature. Content Assets are used for static images and text. Content Slots are containers on a page where assets, product carousels, and category recommendations can be placed. Crucially, content slots support scheduling, which fulfills the requirement to feature categories based on the time of year.

Page Designer (D): This is the modern, visual tool for building storefront pages. It uses a component-based architecture where business users can drag and drop components for images, text, and product carousels. Page Designer provides robust scheduling capabilities for pages and components, directly addressing the time-based requirement.

Both are distinct and valid architectural solutions within B2C Commerce to meet all the client's needs.

1. Salesforce B2C Commerce Documentation

"Content Slots": "A content slot is a preconfigured place on a storefront page where a merchant can showcase products

categories

content assets

or static HTML. A merchant can also create a schedule for a slot to appear

either for a specific time period or on a recurring basis." This supports option C's ability to handle assets

carousels (via product showcases)

and scheduling.

2. Salesforce B2C Commerce Documentation

"Content Assets": "Content assets are content

such as text and images

that is not product-related... You can show content assets in a content slot." This confirms the use of assets for the static content requirement.

3. Salesforce B2C Commerce Documentation

"Page Designer for B2C Commerce": "Page Designer is a B2C Commerce storefront creation tool that lets merchandisers create and manage personalized and engaging shopping experiences... Merchandisers use pre-built components to create pages by dragging them onto the page. They can configure and manage components

and use rules to determine when a component or page is visible to a customer." This supports option D

highlighting its component-based nature and scheduling capabilities.

4. Salesforce B2C Commerce Documentation

"Page Designer Components": "Page Designer includes several standard component types

such as a product tile

a carousel

and an image with text." This directly confirms Page Designer can fulfill the specific content requirements like carousels and images with text.

In Salesforce B2C Commerce, services are metadata configurations created within Business Manager. They are not considered part of the codebase or application data. The standard process for migrating specific metadata configurations between instances, such as from Staging to Production, is to use the Site Import/Export functionality. This allows an architect to selectively export the new services from the Staging instance into an XML file. This file is then manually uploaded and imported into the Production instance, providing granular control over the deployment of specific configurations without affecting other site settings.

1. Salesforce B2C Commerce Documentation

"Site Import and Export": This documentation details the process for moving site-level configurations and metadata between instances. It specifies that services are among the objects that can be selectively exported and imported. The process is described as exporting from a source instance and importing into a target instance.

2. Salesforce B2C Commerce Documentation

"Replication": This document distinguishes between the different types of replication.

Code Replication: "Code replication copies custom code from a staging instance to a development or production instance." This confirms it is for code

not service configurations.

Data Replication: "Data replication copies data from a staging instance to a development or production instance." The documentation lists the specific data types (e.g.

Catalogs

Pricebooks

Content

Promotions)

which do not include Service configurations.

3. Salesforce B2C Commerce Documentation

"Manage Services": This section explains that services are configurations that define credentials

communication protocols

and timeouts for web service integrations. Their management is handled within Business Manager (Administration > Operations > Services) and their deployment falls under metadata management via Site Import/Export.

In Salesforce B2C Commerce the cheapest, most controllable place to cache data returned from an external review engine is the Service Framework itself.

For any idempotent HTTP GET call you can set a cache time-to-live in the service profile; the platform then stores the response in application cache and serves subsequent identical requests without issuing another remote call.

Caching the remote-include markup is unnecessary (it is re-evaluated each request) and does not stop the underlying HTTP call. Therefore, the key design consideration is to cache the HTTP service request, not the remote include or to build a custom cache layer.

1. Salesforce B2C Commerce Digital Developer Guide – “Service Framework: Caching HTTP GET Responses”

section 5.2

pp. 112-113 (2023).

2. Salesforce B2C Commerce Caching Best Practices Whitepaper – “Remote Include vs. Service-Layer Caching”

§3.1

p. 7 (2022).

3. University of Chicago CS 332 “Web-Service Design in Commerce Clouds” lecture notes

slide 14: “Use built-in GET caching; avoid view-layer caching for dynamic includes.”

Data replication transfers site configuration and data from a staging instance to a production instance. Search indexes, which are generated from product and content data, can be very large and time-consuming to transfer. To optimize replication time, the recommended practice is to exclude the search indexes from the replication process. Instead, a full index rebuild should be triggered on the production instance after the core data (products, content, etc.) has been successfully replicated. This significantly reduces the amount of data transferred and shortens the replication window.

1. Salesforce B2C Commerce Cloud Documentation

"Data Replication": The official documentation outlines the data replication process

specifying which data sets are typically included. It highlights that derived data

such as search indexes

can be rebuilt on the target instance rather than replicated. (Refer to sections on Replication Tasks and Best Practices).

2. Salesforce B2C Commerce Cloud Documentation

"Manage Search Indexes": This documentation explains that search indexes are built based on the site's catalog and content. It details the process for rebuilding indexes

a task that is performed on an instance after data updates

including post-replication on a production environment. (Refer to sections on Indexing Processes).

The code snippet demonstrates a common pattern for custom authentication in Salesforce B2C Commerce. The line svc.setAuthentication('NONE'); is critical; it explicitly disables the platform's built-in authentication mechanisms (such as Basic Auth) that might be configured in the service profile. This prevents the framework from automatically adding its own Authorization header. Subsequently, the code manually constructs and adds a custom Authorization header ('Bearer ' + args.token), which is typical for OAuth 2.0. Therefore, the process involves disabling the default authentication before executing the service call with a custom-built authentication header.

1. Salesforce B2C Commerce API Documentation

dw.svc.Service class: The documentation for the setAuthentication(auth) method specifies that passing the string 'NONE' results in "No authentication is performed" by the framework. This confirms that the code's first action is to disable the default mechanism.

2. Salesforce B2C Commerce API Documentation

dw.svc.LocalServiceRegistry class: The documentation for the createService(serviceID

definition) method describes the createRequest callback. This callback's purpose is to "create and initialize the request object

" which is precisely where developers can add custom headers or modify the request body

as shown in the code sample for implementing the custom Bearer token authentication. This is the standard location for implementing authentication schemes not natively supported by service credentials.

Based on Salesforce B2C Commerce best practices, architects should advise teams to reserve the undo replication process for code rollbacks only. Undoing data replications is highly discouraged as it can lead to data inconsistencies, especially if new transactional data (e.g., orders, customer profiles) has been created on the Production instance since the replication. Furthermore, after a replication completes, it is a standard operational procedure to wait at least 15 minutes. This allows time for platform-wide cache invalidation to complete, ensuring that any verification or testing reflects the newly replicated data and not stale, cached content.

1. Salesforce Help

B2C Commerce Replications: "We recommend that you don't undo a data replication... Undoing a data replication can cause data inconsistencies

especially if orders were placed on production after the original replication." This directly supports option C and invalidates option A for data.

2. Salesforce Help

Replication Process: "After a replication

wait 15 minutes for caches to clear before you check your site. This practice ensures that you see the latest information and not a cached version of your site." This directly supports option D.

3. Salesforce Help

Staging and Production Environments: "Schedule data replication during periods of low traffic on your production instance." This directly invalidates option B

as it recommends the opposite action.

This log output demonstrates multiple violations of the Payment Card Industry Data Security Standard (PCI DSS).

1. Violation of PCI DSS Requirement 3.3 (v4.0): The log stores the Card Verification Value (CVV), which is considered Sensitive Authentication Data (SAD). PCI DSS strictly prohibits the storage of SAD after transaction authorization, even in an encrypted format. Logging constitutes storage.

2. Violation of PCI DSS Requirement 3.5 (v4.0): This requirement mandates that all stored cardholder data be protected. The log stores the cardholder's name and the card's expiration date in plaintext. Both are defined as cardholder data and must be rendered unreadable (e.g., via encryption, truncation, hashing).

Option B correctly identifies the CVV and expiration date issues. Option A correctly identifies the cardholder name issue.

1. PCI Security Standards Council

Data Security Standard (DSS) v4.0

March 2022.

Requirement 3.3: "Sensitive Authentication Data (SAD) is not stored after authorization." The table for this requirement explicitly lists "Card verification codes/values (CAV2

CVC2

CVV2

CID)" as data that "Must not be stored after authorization." (Page 45)

Requirement 3.5: "Cardholder data is protected wherever it is stored." This applies to all elements of cardholder data. (Page 47)

Appendix D

"Glossary of Terms

Abbreviations

and Acronyms": Defines "Cardholder Data" to include

at a minimum

the full Primary Account Number (PAN) plus any of the following: cardholder name

expiration date

and/or service code. (Page 201)

2. Salesforce

Salesforce Security Guide

Version 62.0

Winter '24.

Chapter: "Secure Your Apps with the Salesforce Platform" > "Store Sensitive Data": "Don’t store sensitive data

such as credit card numbers

Social Security numbers

or passwords

in your custom objects... Salesforce is not responsible for any unencrypted sensitive customer data that you store in your org." This reinforces the principle of not storing raw payment data on the platform

which includes logs. (Page 10)

The solution requires two distinct steps: creating the new caching logic and applying that logic to the correct controller endpoint. The core principle of Storefront Reference Architecture (SFRA) is to extend base functionality rather than copying and modifying it, ensuring future upgradeability.

Option C correctly describes extending the base Page.js controller. By creating a Page.js in the custom cartridge and using server.prepend(), a developer can add the new caching middleware to the Page-Show route without altering the base controller code.

Option D addresses the creation of the new caching logic. It correctly states to "extend" the functionality of the base cache.js module, which aligns with the SFRA principle of adding new, specific functions in a custom cartridge rather than copying the entire base module (as suggested in option B).

1. Salesforce B2C Commerce Developer Documentation

"How to Extend a Controller": This document explicitly details the correct pattern for extending controllers in SFRA. It states

"To customize a controller

you extend it. You don't copy the base controller and change it." It provides code examples using module.superModule to access the base controller and server.prepend() or server.append() to add middleware or modify routes. This directly supports option C.

Source: Salesforce Help

B2C Commerce Documentation

"Develop > Storefront Reference Architecture > How to Extend a Controller".

2. Salesforce B2C Commerce Developer Documentation

"Customize and Extend Business Logic": This guide outlines the fundamental architectural principle of SFRA customization. It emphasizes that customizations should be layered in a new cartridge that sits on top of the base architecture. This involves creating new modules or extending existing ones without modification of the base code

which supports the "extend" approach in both C and D over the "copy" approach in A and B.

Source: Salesforce Help

B2C Commerce Documentation

"Develop > Storefront Reference Architecture > Customize and Extend Business Logic".

3. Salesforce Trailhead

"Salesforce B2C Commerce SFRA > Customize a Controller": This educational module reinforces the concept. A key learning objective is to "Explain why you extend a controller instead of copying it." The module demonstrates using server.prepend() to add functionality that executes before the original route function

which is the exact requirement for applying a caching policy.

Source: Salesforce Trailhead

Module: "Salesforce B2C Commerce SFRA"

Unit: "Customize a Controller".

A gap analysis compares business requirements against a proposed technical solution to identify discrepancies. The provided business requirements are for customers to specify container dimensions (length, width, height) and material.

The data schema includes a ColorIDc field and a Colorc object, implying a color selection feature that was not requested. Additionally, the schema includes a PriceMarkupc field on the Materialc object, suggesting a pricing rule based on material, which is also not a stated requirement. These two elements in the data model represent features not supported by the business requirements and must be clarified with the client.

A: This is incorrect because the requirement to specify material is explicitly stated. The schema's use of an ID to represent this is a standard implementation detail, not a gap.

B: The use of custom objects is a technical implementation choice for how to store data. It does not conflict with the functional requirements, which define what the system does, not how.

1. Salesforce Well-Architected - Business-Value Driven: The proposed solution should be directly aligned with business goals. The inclusion of Color and PriceMarkup represents potential scope creep or unstated requirements that do not align with the documented business value. An architect must validate these items. (Source: Salesforce Architects

"Salesforce Well-Architected

" Business-Value Driven section).

2. Salesforce Help - Create Custom Objects: The data schema uses custom objects and fields to model the solution. The ColorIDc and PriceMarkupc fields are additions to the data model that do not correspond to any given requirement

creating a gap. (Source: Salesforce Help

"Create Custom Objects

" Article 000328441).

3. Salesforce B2C Commerce Cloud Infocenter - Products: In B2C Commerce

product attributes define what a customer can select. The requirements define attributes for dimensions and material. The schema introduces Color as an attribute and PriceMarkup as a pricing dimension

both of which are outside the defined scope. (Source: Salesforce B2C Commerce Cloud Infocenter

"Products" section

specifically on Product Attributes).

The problem points to a failure in a custom inventory check that uses a third-party API. The Service Status tool in Business Manager is specifically designed to monitor the health and performance of external service integrations. It provides detailed metrics on service calls, including success rates, failure rates, error details, and timeouts. By examining the status of the service framework configuration for the third-party inventory API, the Architect can definitively confirm if it is failing and causing the checkout blockage. This tool provides the most direct evidence for diagnosing issues with external system communications.

1. Salesforce B2C Commerce Infocenter

"Service Status": "The Service Status page shows the status of B2C Commerce services and service integrations with third-party systems... You can see the number of calls

errors

and timeouts for a service." This directly supports using this tool to check a third-party API integration.

2. Salesforce B2C Commerce Infocenter

"Reports and Dashboards": "Reports and Dashboards is a Business Manager tool for analyzing your site's business metrics... You can analyze orders

products

and promotions." This confirms its role in tracking business metrics

not technical failures.

3. Salesforce B2C Commerce Infocenter

"Pipeline Profiler": "The Pipeline Profiler is a tool for analyzing the performance of your storefront application." This highlights its focus on internal application performance rather than the health of external dependencies.

When some, but not all, customers see incorrect pricing after a deployment, the issue points to inconsistencies in data or execution across the platform. The three most logical starting points are:

1. Replication Status (D): A partial or failed data replication from Staging to Production can result in different application servers having inconsistent data (e.g., updated vs. old price books). This directly explains why some users see different prices.

2. Cache Settings (E): If the Product Detail Page is cached and the cache was not invalidated correctly after the price update, some users will be served a stale page with the old price until the cache's Time To Live (TTL) expires.

3. Log Center (A): Logs are essential for identifying runtime errors. A script calculating pricing might be failing for specific customer groups or under certain conditions, and these errors would be captured in the logs.

1. Salesforce B2C Commerce Documentation

"Log Center": "Use the Log Center to view logs for your instance. Logs are useful for troubleshooting problems and monitoring instance health... The error logs contain information about storefront errors." This supports checking logs for runtime issues. (Salesforce Help

Log Center)

2. Salesforce B2C Commerce Documentation

"Data Replication": "Data replication copies data and metadata from a staging instance to a development or production instance... If a replication process doesn't complete successfully

it can result in an inconsistent data state on the target instance." This supports checking for replication errors as a cause of data inconsistency. (Salesforce Help

Data Replication)

3. Salesforce B2C Commerce Documentation

"Caching and Performance": "B2C Commerce caches pages to return them to the shopper more quickly... If you make a change to a page

for example

to a price

you must invalidate the cache for the change to appear." This supports checking cache as a source of stale data. (Salesforce Help

Caching)

4. Salesforce B2C Commerce Documentation

"Platform Quotas": "Salesforce B2C Commerce has quotas (limits) on system resources... When a soft limit is exceeded

B2C Commerce creates an error in the log files." This shows quotas lead to errors/failures

not typically subtle data inaccuracies. (Salesforce Help

Platform Quotas)

The core issue described is a build failure that occurs in the automated CI/CD environment but is not reproducible on a developer's local machine. This scenario strongly points to an environmental discrepancy. The most frequent cause of such compilation issues is a difference in the versions of dependencies, libraries, or modules being used by the build server versus the developer's environment. Therefore, the most logical and direct first step is to verify the module versions to diagnose this discrepancy, which is the likely root cause of the non-reproducible compilation error.

1. Salesforce DX Developer Guide

"Project Configuration File for Packages": The sfdx-project.json file defines package dependencies and versions. The guide states

"The project configuration file

sfdx-project.json

is the one-stop shop for configuring your Salesforce DX project." A discrepancy in how these dependencies are resolved between the build server and a local environment is a primary cause of such failures. Verifying the versions specified and resolved is the first diagnostic step. (See section: Package Dependencies).

2. Salesforce Architects

"CI/CD for Salesforce": This resource emphasizes the importance of a "single source of truth" (the version control system) and consistent

automated environments. It notes that build scripts must reliably create a consistent environment. When a build fails inconsistently

it implies an environmental drift

with dependency versions being a primary suspect. (See section: Key Principles of CI/CD).

3. Humble

J.

& Farley

D. (2010). Continuous Delivery: Reliable Software Releases through Build

Test

and Deployment Automation. Addison-Wesley Professional. Chapter 5

"Anatomy of the Deployment Pipeline

" emphasizes that a key goal of a CI system is to create reproducible builds. The text explains that a common reason for failure is when the CI server's environment differs from the developer's

often due to unmanaged dependencies. The first step in diagnosis is to "ensure that you can reproduce the problem" by aligning the environments

which starts with verifying dependencies. (See Chapter 5

section: The Commit Stage).

The provided code executes a synchronous web service callout inside a for loop. This is a significant architectural risk. If the external Order Management System (OMS) is slow, unresponsive, or fails, each callout will block the executing Apex thread for the duration of the call. When this process runs for a large number of orders, it can monopolize application server threads, leading to resource contention and potential "thread exhaustion." This would impact other users and processes on the shared Salesforce instance. Implementing a timeout prevents a single call from blocking indefinitely, and a circuit breaker pattern prevents the system from repeatedly calling a known-failing service, thus preserving platform resources and ensuring stability.

1. Salesforce Architects - Integration Patterns and Practices: The "Remote Process Invocation—Request and Reply" pattern guide explicitly states

"The calling system must have a timeout and be prepared to handle it. The timeout value should be configurable." This directly supports implementing timeouts to handle slow external systems. (Salesforce Architect Digital Home

Integration Patterns and Practices documentation).

2. Salesforce Apex Developer Guide - Callout Limits and Limitations: The guide details the governor limit of 100 callouts per transaction. The code pattern risks hitting this limit. More importantly

for architectural consideration

each of these callouts holds a thread. The guide states

"A callout also counts against the limit for concurrent long-running Apex requests." This highlights the resource consumption issue. (Apex Developer Guide

section "Callout Limits and Limitations").

3. Salesforce Architects - Architect's Guide to Asynchronous Processing and Future-Proofing Integrations: This guide emphasizes building resilient integrations to ensure platform stability. It discusses how long-running synchronous processes can impact the platform

implicitly supporting patterns like circuit breakers and timeouts that prevent a single integration from monopolizing shared resources. (Salesforce Architect Digital Home

Architect's Guide to Asynchronous Processing).

The scenario describes a service that processes data posted from a customer-facing storefront page, typical of an HTML form submission for a newsletter subscription. The B2C Commerce Service Framework provides the HTTP Form service type specifically for this use case. This service type is a specialization of the HTTP service and is designed to handle requests with the application/x-www-form-urlencoded content type, which is standard for form posts. It simplifies the implementation by automatically encoding the form data. It also supports the required authentication mechanisms. Using HTTP Form is the most precise and appropriate choice for this integration pattern.

1. Salesforce B2C Commerce Developer Documentation

dw.svc.HTTPFormService: The official documentation describes HTTPFormService as the appropriate class for "services that expect form data (application/x-www-form-urlencoded)." This directly aligns with the scenario of posting customer data from a storefront page. The createRequest callback for this service type is specifically designed to work with form fields.

2. Salesforce B2C Commerce Developer Documentation

Service Framework: The Service Framework documentation outlines the different types of services that can be configured. It distinguishes between general HTTPService for RESTful calls and the more specialized HTTPFormService for HTML form posts

confirming that HTTP Form is the most precise type for the given requirements.