Salesforce B2C Commerce Developer

Cartridges are how features layer on top of each other. You structure a cartridge, set the cartridge path so overrides resolve in the right order, load site data and create a new site.

• Cartridge structure
• The cartridge path and override order
• Per-site cartridge paths
• Importing site data through Business Manager
• Creating a new site
• Storefront Reference Architecture as a base

You build A site with two cartridges whose path order is proven by an override.

Merchants live in the catalog. You manage product types, catalogs and categories, set prices with price books, and track stock with inventory lists, and see how each affects what shoppers see.

• Product types: standard, master, set and bundle
• Catalogs, categories and assignments
• Product attributes and variations
• Price books and price tables
• Inventory lists and allocation
• Importing and exporting product data

You build A catalog with variation products, price books and inventory loaded through import.

Shoppers find products through search more than navigation. You configure search indexes, refinements and sorting rules, and learn how relevance and synonyms shape results.

• Search indexing and rebuilding
• Search refinement definitions
• Sorting rules
• Synonyms, stop words and relevance
• Search suggestions
• Diagnosing a missing product in search

You build A tuned search experience with refinements, sorting and synonyms.

Checkout depends on payment and shipping setup, and the storefront on its content. You configure payment methods and processors, shipping methods and rules, and content assets for pages and slots.

• Payment methods and processors
• Shipping methods and shipping rules
• Taxes and tax tables
• Content assets and folders
• Content slots and scheduling
• Testing checkout end to end

You build A checkout configuration with payment, shipping and content, tested end to end.

Page Designer lets merchandisers build pages from components that developers define. You create page and component types with their metadata, scripts and templates, and place them in regions.

• Page types and component types
• Defining attributes in meta files
• Component scripts and render templates
• Regions and restrictions
• Using a component in a page
• Testing Page Designer components

You build A custom Page Designer component and a page that uses it.

ISML is how the storefront turns data into HTML. You use its tags, expressions, includes and decorators, control caching from templates, and keep logic out of the markup.

• ISML tags: isif, isloop and isprint
• Expressions and encoding
• Includes, decorators and remote includes
• Template caching with iscache
• Localized templates
• Keeping logic out of templates

You build A product tile and layout built from ISML with caching set appropriately.

Controllers receive requests, prepare data and choose a view. You write routes with the server module, chain and extend them, use middleware, and see what happens on each request.

• Routes with server.get and server.post
• Middleware chains
• Extending routes with append, prepend and replace
• Models and view data
• The request and response objects
• Handling redirects and errors

You build A new route with extended behavior, built without editing base cartridge code.

Forms are the main way attackers reach a store. You define forms and their validation, handle submissions, and protect each form against cross-site request forgery.

• Form definitions and fields
• Server-side validation rules
• Handling submission in a controller
• Error messages and re-rendering
• Protecting forms against CSRF
• Encoding and sanitizing input

You build A validated and CSRF-protected form from definition to storage.

Storefronts serve many markets and need extension points. You localize content with resource bundles and locales, use hooks to extend platform behavior, and store custom data in custom objects.

• Locales and resource bundles
• Localizing currencies and formats
• Hooks and the hooks file
• Registering and calling a custom hook
• Custom object definitions
• Reading and writing custom objects

You build A localized feature that uses a hook and stores data in a custom object.

Real stores talk to other systems and run work in the background. You build service integrations with credentials and profiles, configure and call OCAPI, and write jobs that run on a schedule.

• The service framework: credentials, profiles and callbacks
• Calling an external service safely
• OCAPI Shop and Data APIs
• OCAPI client IDs and permissions
• Job steps and job flows
• Scheduling and monitoring jobs

You build A service integration, an OCAPI call and a scheduled job working together.

A store that works but is slow still loses sales. You configure logging, use page caching, and read the request log and profilers to find and fix the code that costs time.

• Log levels, categories and custom logs
• Reading the request log
• Page and partial caching
• Cache invalidation and expiry
• Code and pipeline profilers
• Diagnosing a slow page

You build A performance fix, with before-and-after evidence from the profiling tools.

Build one feature across the stack: catalog data, a controller, a template, a form, a service and a job. You deploy it to a sandbox, test it, and review it for performance and security.

• Scoping a storefront feature
• Preparing data and configuration
• Writing controller, template and form
• Adding service and job logic
• Reviewing for security and performance

You build A working storefront feature deployed to a sandbox, with notes on its security and performance.