Salesforce-B2C-Commerce-Cloud-Developer Practice Test Questions

Explanation:

Salesforce B2C Commerce uses locale-specific resource bundles to support internationalization. When adding support for German (de), the developer should:

Place the localized strings in a file named checkout_de.properties
Store this file in the same folder as the default bundle: templates/default/resources/

This naming convention ensures that when the storefront locale is set to de, the system automatically loads checkout_de.properties. If a key is missing, it falls back to checkout.properties.

❌ Why the other options are incorrect:

B. checkout.properties in the de locale folder: B2C Commerce does not use locale-specific folders for resource bundles — it uses locale-specific filenames.

C. checkout.properties in the default locale folder: That’s the default bundle, not the German override.

D. de_checkout.properties: Incorrect naming convention — the locale code must follow the base name, not precede it.

Explanation:

To make a product visible in the storefront, the developer must ensure three key configurations are in place:

Catalog Assignment
The product must be part of a storefront catalog that is assigned to the current site in Business Manager.

Online and Searchable Flags
The product should be marked as "Online" and "Searchable" so that it can be shown and found by customers.

Search Index
After adding or updating a product, the search index must be rebuilt to reflect the change and include the product in storefront searches.

Why A is not required
A price is essential for checkout and presentation, but it is not strictly required for visibility. A product with no price can still appear in search results.

Why C is not required
Only variation products require a master. Standard products do not need a master to be visible.

Explanation:

In Salesforce B2C Commerce, the require() method is the correct way to implement lazy loading of scripts. This allows you to load a module only when it's actually needed during execution.

How require() Supports Lazy Loading:
- require() loads a script only when the line is executed.
- Improves controller performance by avoiding loading unused modules during initial execution.
- Can be placed inside route handlers or functions to defer loading.

Example:
server.get('Show', function (req, res, next) {
    var basketHelper = require('*/cartridge/scripts/helpers/basketHelper');
    basketHelper.processBasket();
    next();
});

Why Other Options Are Incorrect:
A. importPackage() – This is for the old Rhino engine and is not supported in CommonJS-based environments like SFCC.
B. $.ajax() – This is a client-side method for sending HTTP requests using jQuery; it has nothing to do with server-side script loading.
C. local include – This is used in ISML templates to include HTML markup or partials, not JavaScript modules.

Best Practice:
Use require() inside route callbacks or functions to load only what is needed, improving performance and reducing memory usage.

Explanation

When a job integrates with an external system, it can suffer performance issues due to delays or blocking. Two key actions help reduce this risk:

Configure a Timeout for the Script Pipelet
Setting a timeout prevents the job from hanging indefinitely if the external system is slow or fails to respond.
This helps release resources, fail gracefully, and maintain system responsiveness.

Use Asynchronous Import or Export Jobs
Asynchronous jobs allow execution to continue without waiting on external systems.
They free up threads and avoid bottlenecks caused by synchronous processing.

Why A and C Are Incorrect
A. Synchronous jobs block operations, increasing the chance of performance issues.
C. Disabling multi-threading reduces concurrency and can hurt overall performance.

Explanation:

To deliver personalized content to VIP customers during a promotional period, the developer should configure the following: Slot Configuration
Defines what content appears in the slot, when it appears, and under what conditions (e.g., customer group and time-based rules). This is where the developer sets up targeting for VIP customers and schedules the promotional content.

Rendering Template
Controls how the content is displayed within the slot. It can be customized to show banners, product carousels, or tailored messaging for high-spending users.

Why A and B are not required

VIP Customer Group
While this group is used in the slot configuration rules, it is typically created by merchandisers in Business Manager — not by developers.

Page Template
Not necessary for slot-based personalization. The slot can be embedded in existing templates without creating a new one.

Explanation:

To support locale-specific model values on products in Salesforce B2C Commerce, you should configure the product attribute as localizable.

Why B is Correct:
- A localizable attribute allows different values for each site locale (e.g., en_US, de, fr).
- This is the standard method for storing translated or region-specific data like model numbers, names, or descriptions.
- Values can be set in Business Manager per locale or imported through catalog files.

Why Other Options Are Incorrect:

A. Utilize resource bundles – Resource bundles are meant for UI and template labels, not for dynamic product data like model values.
C. Store translated model values in different fields – This is inefficient, hard to maintain, and goes against best practices.
D. Add model to a custom object – Using a custom object adds unnecessary complexity. Product attributes should be stored directly on the product object.

How to Implement in Business Manager:

1. Go to Administration > System Object Types > Product
2. Add or edit the custom attribute (e.g., model)
3. Check the "localizable" option
4. Save and enter translated values in the appropriate locale contexts

Explanation:

To resolve performance issues in Salesforce B2C Commerce, especially when product tiles are not being cached long enough, it’s important for developers to verify where caching is configured and how it is behaving. Product tiles are rendered frequently across the site, and inefficient caching can lead to performance bottlenecks. The following two methods are effective ways to verify cache settings:

✅ Correct Answers:

A. Enable cache information in the storefront toolkit and view the cache information for the product tile.
The Storefront Toolkit provides developers with a way to inspect cache behavior directly in the storefront. By enabling cache information, the developer can:

See if a tile is cached
View cache hit/miss status
Check cache lifespan and ID
This is a direct method to confirm whether the product tile is being cached and for how long.

C. View the product list page cache settings provided in the Administration > Manage Sites Business Manager module.
Within Business Manager, under Administration > Sites > Manage Sites, developers can view and edit cache settings for pages, including the product list page. This section controls:

How long different page types are cached
What components (e.g., product tiles) are cached
Cache behavior by pipeline or controller

This helps ensure that the correct cache duration is configured for product tiles rendered on category or search result pages.

❌ Incorrect Options:

B. View the cache information provided by the Merchant Tools > Technical Reports Business Manager
Technical Reports are used to analyze job execution, logs, and system performance, but they do not provide visibility into product tile cache settings or durations.

D. Enable the template debugger to verify the cache times for the producttile.isml template
The Template Debugger is helpful for viewing template rendering and data passed to ISML files, but it does not display cache timing or metadata. It’s intended more for logic flow and variable inspection than cache diagnostics.

Explanation:

To use a custom tag in an ISML template in Salesforce B2C Commerce (SiteGenesis), the correct syntax is:
< isinclude template = " util / customtags " >

Why Option B is Correct?
< isinclude template = " util / customtags " >

This directive loads all registered custom tags into the current ISML template.
It is the standard method in SiteGenesis to make custom tags available for use.

Why Not the Other Options?

Option A ()
Used for including JavaScript modules, not custom tags.

Option C ()
Incorrect syntax—custom tags are not loaded via URL.

Option D ( dw.util.CustomTagMgr.createCustomTag("mytag"); )
This registers a new custom tag but does not make it available in the template.

Explanation:

Universal Containers wants to switch from showing a static content asset to dynamic product recommendations (top 5 selling boxes for the week). This requires:

✅ B. Change the slot’s configuration content type to “recommendations.”
The slot must now use Einstein Product Recommendations.
This content type enables dynamic product lists based on strategies like top sellers, recent views, or affinity.
The “recommendations” type is specifically designed to pull data from Einstein algorithms.

✅ C. Change the slot’s configuration template to the appropriate rendering template.
The ISML template used for rendering must support product recommendations.
It should loop through the slotcontent.content collection and render each product appropriately.

Example template logic:
< isloop items = " $ {slotcontent . content } " var = " product " >
< isprint value = " $ { product . name } " >< / isprint >
< / isloop >

❌ Why the other options are incorrect

❌ A. Change the slot’s configuration content type to “products.”
This would be used for manually selected products, not dynamic recommendations.
It doesn’t leverage Einstein’s algorithms.

❌ D. Delete the existing content asset.
Not necessary. You can simply disable or replace the slot configuration.
Content assets can coexist with other configurations and be reused elsewhere.

Explanation:

To log the HTTP status code in a debug-level custom log file, the correct syntax in Salesforce B2C Commerce (SFCC) is:
Logger.getLogger('profile').debug("Error retrieving profile email, Status Code: {0} was returned.", http.statusCode);

Why Option D is Correct?

Logger.getLogger('profile')
Creates/retrieves a custom logger named 'profile' (logs appear in logs/profile.log).
.debug()
Logs the message at debug level (visible when debug logging is enabled).
{0}
Placeholder for the status code (http.statusCode).

Why Not the Other Options?

A. logger.getLogger(‘profile’).debug(...)
Incorrect: logger is not defined (should be Logger, the SFCC system class).

B. logger.debug(...)
Incorrect: logger is undefined, and no custom log file is specified.

C. Logger.getLogger().debug(...)
Incorrect: Missing log file name (e.g., 'profile').