B2C-Commerce-Developer Salesforce Certified B2C Commerce Developer (SP25) Free Practice Exam Questions (2025 Updated)

For creating a new service instance in Salesforce B2C Commerce that calls a remote web service, the correct method to use is dw.svc.LocalServiceRegistry.createService(), as shown in Option A. This method allows developers to define a service configuration that specifies various aspects of the service call, such as the endpoint URL, request method, credentials, and other necessary parameters. By using LocalServiceRegistry.createService(), the developer can leverage the built-in service framework in B2C Commerce, which facilitates the management and execution of external service calls, including error handling and connection pooling.

The likely reason the merchandiser does not see the Search Refinement when searching for "Clothing" via the Storefront search, despite it being configured for the Clothing category, is option B: "The Search Refinement definition is not set up for the Women category." Search Refinements need to be set up at each level of the category hierarchy to be effective in searches that aggregate products across those categories. If the refinement is only set for "Clothing" but not for "Women," it won't appear in searches that include items from the broader "Women" category or that are initiated from a higher category level.

Selecting “Show Orderable Products Only” in the Search Preferences of the Business Manager in Salesforce Commerce Cloud effectively filters out products that are not available for sale (ATS = 0). This setting helps in enhancing customer experience by only displaying products that customers can actually purchase, thereby minimizing customer frustration and potential confusion about the availability of products. This setting does not specifically filter out back-ordered or pre-order products unless their ATS is zero.

To address issues with CSRF (Cross Site Request Forgery) where tokens are either missing or invalid, the developer can take the following actions:

Add the token in the ISML template: This ensures that the CSRF token is included in forms or requests originating from the template, making them secure against CSRF attacks.

Add csrfProtection.generateToken as a middleware step in the controller: Integrating this middleware ensures that a valid CSRF token is generated and validated for every request that passes through the controller, securing the application against CSRF attacks. This approach is proactive and systematic, ensuring CSRF protection is embedded within the application flow.

These measures reinforce the security of the site by ensuring CSRF tokens are correctly handled, minimizing potential CSRF vulnerabilities.

For improving client-side performance, several techniques are considered best practices:

Place CSS outside of templates (B): External CSS files can be cached by the browser, reducing the need to download them for every page load. This also separates content from style,

which aids in maintaining cleaner HTML and potentially speeds up page rendering times.

Compress CSS (C): Compressing CSS files reduces their size, leading to faster download times. This can be achieved through minification, which removes unnecessary characters from code without changing its functionality.

Combine several images into a single image (CSS sprites) (E): Using CSS sprites combines multiple images into one larger image that is downloaded as a single file. This reduces the number of HTTP requests needed for loading multiple images, thereby decreasing load times and improving performance.

In Salesforce B2C Commerce, to manage the rate of calls made to external services and to prevent exceeding the limit of allowed calls, developers can configure a rate limiter directly in the service profile. This involves setting up specific thresholds that define the number of calls that can be made per second. This setup ensures that the integration adheres to external service limitations or internal performance considerations by controlling the rate at which requests are sent. The configuration of rate limiting is critical in environments where multiple calls are made to external APIs, which might have their own limitations on how often they can be accessed. This practice not only adheres to the best use of external services but also helps in maintaining the stability and performance of the application.

If a developer's log messages are not appearing in the WebDAV folder as expected, it is likely due to configuration issues related to logging settings or scheduled jobs that handle log file management. Importing the "Search settings" and "Site Jobs" XML files can help resolve these issues. The "Search settings" may contain configurations that affect how search operations are logged, while the "Site Jobs" settings are crucial for managing scheduled tasks, including those that may be responsible for processing and storing log files. Importing these configurations ensures that all necessary settings are correctly set up in the developer's sandbox, which can address issues related to logging output and file management.

The method ProductSearchModel().getProductSearchHits() is efficient and scalable because it utilizes the product search index rather than conducting a direct search within the database. This indexing method enables quicker retrieval of product information and is optimized for performance in scenarios where multiple products need to be fetched based on various criteria. Using the product search index means that data retrieval is managed through indexed fields, which is significantly faster than querying a database directly for each request. This approach not only improves performance but also reduces the load on the database, making it a scalable solution for e-commerce environments where high traffic and large product catalogs are common.

In the Salesforce B2C Commerce logging system, logs are categorized by severity levels, which include DEBUG, INFO, WARN, and ERROR. With the log level set to WARN in the Business Manager, any log entries with a severity of WARN or higher (which includes ERROR) will be recorded. Therefore, the messages from log.warn("This is a warn message") and log.error("This is an error message") will be written to the log. The INFO and DEBUG messages will not be recorded since their severity is lower than the WARN level set in the configuration.

To best expose data for rendering in an SFRA-based architecture, especially when dealing with custom attributes such as a special icon for monobrand stores, the recommended approach is to use the module.superModule functionality along with a call method. This approach allows extending the functionality of an existing model without altering the base code directly. By using module.superModule, the developer can add new properties to the Store Model effectively and maintainably, adhering to SFRA's extension and customization best practices.

To integrate with an external web service using HTTP requests and set up a testing mechanism using the Service Framework in Salesforce B2C Commerce, the best approach is to implement the mockFill callback and set the service mode to "mock". This configuration allows the developer to test the integration with a simulated response from the service. By using the mockFill method, developers can specify the expected response from the external service when it is not yet available. This approach is particularly useful for testing and debugging the integration in a controlled environment before the actual web service goes live. Setting the service mode to "mock" enables this simulated environment, ensuring that the service behaves as if it is interacting with the actual external service.

QUESTIONNO: 67

A developer needs to update the package.json file so that it points to the hock file for a cartridge, using the hooks keyword. Which snippets work correctly when added to the file?:

A. { “hooks”: “./cartridge/scripts/hooks.json” }

B. { “hooks”: “./scripts/hooks.json” }

C. { hooks: “./cartridge/scripts/hooks.json” }

D. { hooks: ./scripts/hooks.json }

Answer: A

In the context of Salesforce B2C Commerce Cloud, particularly when configuring hooks in a package.json file for a cartridge, the correct format to specify the location of the hooks configuration file must be a valid JSON string. The snippet { "hooks": "./cartridge/scripts/hooks.json" } is correctly formatted as it includes double quotes around both the key and the value, which is a requirement in JSON syntax. The path ./cartridge/scripts/hooks.json correctly assumes that the hooks configuration file is located within a cartridge in the scripts directory, which is a common setup in SFCC. This matches best practices as documented in the Salesforce Commerce Cloud Script API documentation and developer guides.

To enable customers to refine product search results by a custom attribute like weightCapacity, the developer must first define this attribute as a search refinement in the system's configuration. This involves setting up the attribute in the Business Manager under the search refinements settings for the applicable category or globally. Once this setup is complete, rebuilding the product search index is necessary to apply these changes and ensure the search engine recognizes weightCapacity as a refinement attribute. This process updates the search index with the new configuration, allowing the attribute to be used as a filter in storefront search functionalities.

In Salesforce Commerce Cloud, a shared library is used to manage content assets that can be accessed across multiple sites. This setup is particularly useful in multi-site configurations where certain content, like media files, branded content, or general information, needs to be consistent across different sites. The shared library allows for central management of these assets, reducing duplication and ensuring consistency. It does not, however, typically handle content slots or locale-specific content directly; those are usually managed at the site or locale level to cater to specific market or regional needs.

When converting a pipeline to a JavaScript controller and needing to debug the controller in Salesforce B2C Commerce, you must set up an appropriate debugging environment that supports JavaScript controllers specifically:

Option D: Create and use a new controller debug configuration is the correct answer. This is because the debugging tools and configurations for pipelines are different from those used for JavaScript controllers. A controller debug configuration specifically targets the debugging of server-side JavaScript, allowing breakpoints, step-through, and inspection of JavaScript code executed on the server.

Option A refers to a generic script debug configuration, which might not be specific enough. Option B and C, related to pipeline debuggers, are not applicable to JavaScript controllers, as they are designed for the older pipeline architecture.

After the server-side controller code is defined in Salesforce B2C Commerce Cloud, it is necessary to ensure that it can be consumed by other parts of the application. This is done by exporting the server object. The correct way to make a server-side controller available for page component display is by using the server.exports() method. This approach is validated by typical usage patterns seen in the SFRA where controllers are modular and need to be exported for application-wide accessibility.

To disable Apple Pay for a specific country such as Spain, the appropriate module in the Salesforce B2C Commerce Business Manager is:

Merchant Tools > Site Preferences > Payment Types (D): This module allows the developer to configure and manage different payment methods available on the site, including enabling or disabling them for specific countries or regions.

Options like Payment Methods (A) and Payment Processors (C) generally deal with setting up and managing the details of how payments are processed but do not specifically allow for enabling/disabling payment methods by country. There is no specific module under "Apple Pay" in Site Preferences (B), as Apple Pay settings would be grouped under general payment types settings.

For a developer to integrate an external application for managing store information with the B2C Commerce Staging instance, the appropriate technique is to use a POST request to the Stores Data OCAPI. This approach is used to create new store entries in the system. POST requests are standard for creating new resources in RESTful APIs, including the OCAPI used by Salesforce Commerce Cloud, which aligns with the method's definition and intended use for adding new data to a collection of resources.

In Salesforce Commerce Cloud, the proper storage location for translation files for specific locales follows a structured directory path to ensure that the system correctly recognizes and applies the translations. The correct path for storing locale-specific translation messages, such as for the French locale, is under cartridge/templates/resources/fr. This structure allows the platform to efficiently load the appropriate resources based on the locale settings, ensuring that the correct translations are displayed for each supported locale.

When importing configurations specific to different sites into the same sandbox, the XML files that should be imported using site-specific Merchant Tools rather than through the Administration section are: B. Site Jobs - These files relate to scheduled jobs configured at the site level, containing settings and parameters specific to operations within individual sites. D. Promotions - These involve marketing and promotional settings that are typically specific to individual sites, affecting how discounts and special offers are applied and managed within that site's context. Importing these using the site-specific Merchant Tools ensures that configurations apply correctly and are managed in the context of the intended site, maintaining consistency and specificity in site operations.