Free Salesforce B2C Commerce Developer Practice Test 2026 | Edurely

Salesforce B2C Commerce Developer Practice Test 

The Salesforce B2C Commerce Developer certification is designed for developers who build, extend, and troubleshoot ecommerce storefronts on Salesforce B2C Commerce. Candidates can Work through online certification questions while using this guide to connect practice results with the current official blueprint, hands-on development tasks, and Salesforce documentation.

Preparing for this certification requires more than knowing JavaScript terms. Students need to understand how a B2C Commerce site is configured, how catalogs and storefront data work together, how Storefront Reference Architecture (SFRA) applications are extended, and how custom code affects security, performance, and maintainability. A useful practice test should therefore measure applied judgment instead of simple recall.

Who Should Use This Preparation Guide?

This guide is useful for developers who already understand basic JavaScript, HTML, CSS, REST concepts, Git, and Node.js but need a focused path into B2C Commerce. It can also help experienced Commerce Cloud professionals find gaps before attempting mixed practice assessments.

Students benefit most when they have access to a B2C Commerce sandbox. Reading can explain a cartridge path or custom object, but performing the task makes the sequence easier to remember. Where a sandbox is unavailable, learners can still examine documented code structures, draw request flows, review SFRA examples, and write decision-based notes.

A candidate is moving toward developer-level readiness when they can answer three questions about a feature:

1. What business or technical need does it solve?
2. How is it configured or implemented?
3. What security, performance, or maintenance risk can arise from using it incorrectly?

Current Salesforce B2C Commerce Developer Topics

The following sections retain the official domain names and percentages. The explanations translate the objectives into student-friendly language without presenting supplementary topics as part of the official blueprint.

1. B2C Commerce Setup — 11%

This domain covers the tasks required to prepare a sandbox and connect code, configuration, and storefront data correctly.

Configure development tools and deploy cartridges

Candidates should understand how a development environment connects to a sandbox and how WebDAV is used to place cartridges in the correct code-version directory. A cartridge packages application code or data so that functionality can be reused, extended, or integrated.

Salesforce’s current cartridge documentation explains that cartridges can contain controllers, templates, scripts, form definitions, static content, and integration files. Learners should understand the directory structure as well as the deployment purpose.

Practice scenarios may describe code that has been uploaded successfully but is not visible on the storefront. The problem might involve an inactive code version, the wrong directory, an incorrect cartridge path, or an error inside the cartridge. A developer should check these possibilities in a sensible order rather than uploading the same code repeatedly.

Import data through Business Manager

The official objective includes importing files using Business Manager’s Import and Export modules. Students should know that code deployment and data import are different operations. Products, catalogs, inventory, price books, content, sites, and system configuration can have distinct import structures and dependencies.

Before importing, review the file structure, identifiers, mode, target, and order of dependent data. After the import, inspect the process result and validate the data in Business Manager or the storefront. A completed import process does not automatically prove that the resulting site behavior is correct.

Configure the cartridge path

Cartridge order matters because B2C Commerce resolves modules and resources through the cartridge path. When one cartridge is intended to extend or override another, its position affects which implementation is found.

Strong preparation should cover both the expected order and the maintenance reason behind it. Directly editing Salesforce-owned base code may appear faster, but it makes upgrades and comparisons with the supported base more difficult. Custom functionality is usually kept in a separate cartridge and applied through supported extension patterns.

Create a site and assign storefront data

Candidates should be able to create a site with the correct default currency and taxation type, then assign the data required by the storefront. This includes relevant catalogs, inventory lists, price books, libraries, and other site-level configuration.

These assignments are connected. A product can exist but remain unavailable or incorrectly priced if its catalog, category, price book, inventory list, or site assignment is missing. Practice questions should help students trace a storefront symptom back through those relationships.

Practice focus: Build a clean setup checklist covering sandbox access, development tools, code versions, WebDAV, cartridge deployment, cartridge order, data import, site creation, and storefront assignments.

2. Work With a B2C Site — 12%

This domain covers the business-facing storefront configuration that developers must understand when building and troubleshooting ecommerce features.

Work with the product and search models

Students should know how products, variants, categories, storefront catalogs, inventory lists, and price books work together. They should also understand the role of the product search model.

An e-commerce product is rarely just a title and price. A storefront may need variants for size or color, category assignments for navigation, inventory records for availability, price-book entries for selling price, and searchable attributes for discovery. When one relationship is missing, the storefront may show incomplete or unexpected results.

A good practice scenario might describe a product that appears in Business Manager but not in search. The learner should consider online status, site assignment, category assignment, search-index status, availability, price, and searchable attributes before assuming that application code is broken.

Enable checkout through payment and shipping configuration

The official outline expects candidates to use Business Manager settings that allow shoppers to complete storefront orders. This requires an understanding of payment methods, shipping methods, country or region rules, currency, taxation, and site configuration.

The key is to follow the shopper journey. A shipping method may exist but not apply to the basket’s location or product. A payment option may be configured but unavailable because of currency, customer, or integration conditions. Practice should teach candidates to identify the rule that prevents checkout from continuing.

Manage storefront content

Candidates should be familiar with Content Assets, Content Folders, Content Slots, and Page Designer. These tools give business users controlled ways to manage content without changing application code for every campaign.

Content Assets store reusable content. Content Folders organize content. Content Slots place scheduled or targeted content in defined storefront locations. Page Designer uses developer-created page types and component types so marketers can assemble pages visually.

The developer’s job is to create safe and reusable building blocks. A component should expose useful configuration without forcing a marketer to understand code. It should validate input, render correctly across supported devices, and avoid unnecessary performance cost.

Practice focus: Map products, prices, inventory, search, shipping, payment, and content to the shopper journey from discovery through checkout.

3. Data Management Using Business Manager Usage — 24%

This domain connects configuration, data modeling, debugging, API access, services, and performance. It is the second-largest area and deserves regular hands-on practice.

Configure search preferences, refinements, and sorting

Search configuration determines how shoppers find products. Candidates should be able to modify search preferences, make suitable attributes searchable, create refinements, and define sorting behavior.

A refinement helps shoppers narrow results by useful product properties such as category, brand, size, or color. A sorting rule changes the order in which results appear. Before exposing an attribute, developers should consider data quality, indexing, localization, and whether the value is meaningful to shoppers.

When search results appear wrong, students should check product data, searchable attributes, refinement definitions, sorting configuration, category assignments, and index status. Rebuilding an index can be necessary after some changes, but it should not replace finding the underlying configuration issue.

Configure logging and investigate problems

The official outline includes logging categories and access to logs through Business Manager. Developers should understand how to choose an appropriate log level and write useful, non-sensitive messages.

Good logs explain what happened without exposing customer data, payment information, credentials, tokens, or secrets. A useful message includes safe context that helps identify the component, request, job, or integration involved. Excessive logging can create noise and make the important event harder to find.

Extend system objects and create custom objects

B2C Commerce provides many system object types. Developers can add custom attributes when the business needs additional fields on an existing object. When data does not naturally belong to an existing system object, a custom object may be more appropriate.

The Salesforce custom-object documentation distinguishes custom attributes from custom object types and explains site-specific versus organization-wide object instances. Candidates should learn to choose the smallest appropriate data model rather than creating custom objects for every requirement.

Important questions include:

• Does the data belong to an existing business object?
• Is the value needed per site or across the organization?
• How will it be created, updated, queried, and deleted?
• What volume is expected?
• Does the data require localization?
• Could frequent access create a performance problem?

Diagnose performance and caching issues

Candidates should know how caching and profiling tools help identify slow code. Performance problems may come from repeated object lookups, large loops, unnecessary service calls, poor cache use, oversized API responses, or expensive operations inside a request.

Salesforce’s site-performance guidance warns against patterns such as unnecessary object creation and inefficient OCAPI or controller behavior. The caching guidance also explains that B2C Commerce uses several caching layers. Candidates should therefore think beyond adding a single cache tag.

Caching is a trade-off between speed and freshness. Product, promotion, price, inventory, and personalized data can have different freshness requirements. The correct answer depends on what changes, how quickly shoppers must see that change, and whether the content is safe to share across requests.

Configure OCAPI permissions

The official blueprint specifically names the Open Commerce API Shop and Data APIs. Candidates should understand how client permissions restrict access by resource and method. Grant only the operations required by the integration.

Modern Salesforce documentation also covers Salesforce Commerce API, usually called SCAPI. This is useful current knowledge, but it should not erase the official OCAPI objective. Salesforce describes SCAPI as RESTful APIs for shopper experiences, merchant tools, and integrations. Its current API guide separates shopper-facing APIs authenticated with SLAS from admin APIs authenticated through Account Manager.

For certification preparation, study the official OCAPI objective first. Then understand how SCAPI, OCAPI, and the Script API fit into today’s broader B2C Commerce development landscape.

Understand service configurations

External services may provide payment, tax, address validation, inventory, loyalty, or other functionality. Developers should recognize how service configurations support endpoints, credentials, profiles, timeouts, and operational control.

A reliable integration should handle success, business errors, timeouts, malformed responses, and temporary outages. Credentials should remain outside source code. Logs should contain safe diagnostic information, and the storefront should have an appropriate fallback when the external dependency is unavailable.

Practice focus: Use short troubleshooting scenarios that connect a storefront symptom to Business Manager data, search configuration, logs, permissions, cache behavior, or a service definition.

4. Application Development — 53%

Application Development represents more than half of the official blueprint. Students should spend most of their lab and practice-test time here, while continuing to connect code with the setup and data domains.

Build ISML templates

Internet Store Markup Language, or ISML, is used to render dynamic storefront content. Candidates should understand common ISML tags, expressions, local includes, remote includes, components, conditional rendering, loops, and output.

Salesforce’s ISML reference explains that ISML tags begin with the is prefix and combine live data with page markup. Students should focus on choosing the right rendering method and avoiding business logic that belongs in a controller, model, helper, or script.

Local and remote includes should not be treated as identical. A local include is processed as part of the current rendering flow, while a remote include creates a separate request and can have different caching and performance behavior. Scenario practice should test why an include type fits the requirement.

Troubleshoot scripts and controllers

Candidates should use systematic debugging instead of making random changes. Begin with the route or script involved, reproduce the problem, inspect the relevant logs, confirm request data, and trace the call path.

Common issues include an incorrect cartridge order, a route that is not reachable, a missing next() call in middleware, a module path problem, invalid template data, unsafe assumptions about optional values, or an exception from a service call.

The strongest practice answer normally identifies both the likely cause and the best evidence for confirming it.

Create and extend JavaScript controllers

SFRA controllers receive requests, execute middleware, build view data, and render a template or return another response such as JSON. Salesforce’s SFRA architecture documentation describes a model-view-controller approach in which controllers create ViewModels and pass serializable data to the rendering layer.

Students should understand:

• Route creation with the server module
• GET and POST handling
• Middleware order and completion
• HTTPS and consent-related middleware
• Rendering templates and returning JSON
• Models, decorators, factories, and helper modules
• Extending, prepending, appending, or replacing routes
• Avoiding duplicate side effects when customizing a route

Extending code safely is more important than copying a controller. Salesforce owns and maintains the base SFRA cartridge. Customization patterns should keep custom logic separate when possible so upgrades remain manageable.

Develop Page Designer components

Developers create page types and component types that marketers use inside Page Designer. A component usually combines metadata, server-side logic, a rendering template, and supporting client-side assets.

Practice scenarios should ask what a marketer needs to control, which values require validation, how content is localized, and whether the component can be reused. A component that exposes every technical setting may be flexible for developers but confusing or unsafe for content teams.

Work with forms, validation, persistence, and CSRF protection

Candidates should know how form definitions, rendering, server-side validation, bindings, and object persistence work together. Input must be validated even when browser-side checks exist.

Cross-Site Request Forgery protection is particularly important for state-changing actions. Salesforce’s forms documentation explains the SFRA forms model and the middleware used to validate CSRF-protected requests. Students should be able to recognize where a token must be generated and checked.

Secure form handling includes:

• Accepting only expected fields
• Validating format and business rules
• Encoding output appropriately
• Protecting state-changing requests
• Avoiding sensitive data in logs
• Using transactions for controlled writes
• Showing useful error messages without revealing internal details

Implement localization

Localization can affect templates, form definitions, static files, properties files, and persistent object attributes. It is more than translating visible text. Developers must also consider locale selection, fallback behavior, regional formats, catalog content, currencies, and site configuration.

Practice should include missing translations and locale-specific assets. A page may function correctly in the default locale but fail because a property key, form definition, content value, or file is missing elsewhere.

Write useful custom logs

The official objectives include writing custom messages at appropriate logging levels. Candidates should know the difference between routine diagnostic information and an event that requires warning or error attention.

Never record credentials, tokens, full payment data, or unnecessary personal information. A log message should help support staff locate the failure while protecting shopper privacy.

Integrate B2C Commerce services

Service Framework code should use managed configurations rather than hard-coded endpoints and secrets. Students should understand request creation, response parsing, error handling, timeouts, circuit-breaker behavior where applicable, and log filtering.

Synchronous calls directly affect the shopper’s response time. If an external system is slow, the storefront can become slow. A practice scenario may require deciding whether a task belongs in the live request or an asynchronous job.

Use hook extension points

Hooks allow custom code to run at defined extension points. Salesforce’s SFRA hooks documentation explains that hook registration and execution are affected by the cartridge path.

Candidates should know how hook definitions connect an extension point to a script, how modules are exported, and how several registered hooks may interact. They should also recognize that hooks add maintenance and performance responsibility.

Correct performance and scalability problems

Ecommerce traffic can rise sharply during promotions or peak seasons. Code that works in a small sandbox may perform poorly at production volume.

Common risks include:

• Repeated database or object access inside loops
• Large result sets when only a few records are needed
• Uncached content that is safe to cache
• Personalized data placed in shared caches
• Multiple slow service calls in one shopper request
• Nested remote includes
• Unbounded custom-object growth
• Excessive logging
• Long transactions
• Inefficient hooks executed on high-traffic endpoints

Students should learn to measure before changing code. Identify the slow layer, inspect profiler or log evidence, change one cause, and retest.

Integrate external systems through APIs

The blueprint names OCAPI Shop and Data APIs. Candidates should understand resources, methods, permissions, request and response formats, hooks, and integration use cases. Shop APIs support storefront-oriented operations, while Data APIs serve management and back-office needs.

The current B2C Commerce API documentation lists SCAPI, OCAPI, Script API, and Einstein API resources. Use the official blueprint to define certification scope and the current reference documentation to understand the evolving platform.

Develop scheduled jobs and custom job steps

Jobs support batch processes such as catalog or inventory import, order export, data cleanup, and integration synchronization. Students should understand job flows, step configuration, parameters, status codes, error handling, and transactions.

Salesforce’s custom job-step guidance recommends avoiding one unnecessarily large transaction and managing transactional work deliberately inside the step. A recoverable job should also log safe context and make restart behavior clear.

Practice focus: Spend most of the week writing, tracing, or reviewing SFRA code. For every scenario, identify the request flow, data source, extension point, security control, performance effect, and expected output.

Essential Concepts Explained Simply

What is SFRA?

Storefront Reference Architecture is Salesforce’s reference framework for building B2C Commerce storefronts. It uses JavaScript controllers, models, ISML templates, middleware, forms, and cartridges to organize storefront behavior. It is a starting architecture that developers extend for merchant requirements.

What is a cartridge?

A cartridge is a package of storefront functionality or data. It can contain controllers, templates, scripts, forms, static files, and other resources. The site’s cartridge path determines which cartridges are available and how matching resources are resolved.

What is Business Manager?

Business Manager is the administrative interface used to configure sites, catalogs, products, search, content, inventory, prices, services, jobs, code versions, permissions, and other B2C Commerce functions. Developers use it alongside code rather than treating it as a separate merchant-only tool.

What is the difference between a system-object attribute and a custom object?

A custom attribute adds a field to a supported existing system object. A custom object creates a separate type for additional application data. Choose based on data ownership, access pattern, scope, volume, and lifecycle.

What is the difference between OCAPI and SCAPI?

Both provide REST-based access to B2C Commerce capabilities. The official certification blueprint explicitly tests OCAPI Shop and Data API configuration and integration. Current Salesforce development also promotes SCAPI for shopper and administrative APIs. Candidates should understand the blueprint terminology without ignoring the modern API direction.

How Structured Practice Builds Storefront Development Skills

After reviewing an official domain, students can Choose an Salesforce exam and start practicing to check whether they can apply the concepts in new scenarios. The goal is to expose weak reasoning, not to memorize the order of answers.

A well-organized practice approach can help learners:

• Measure performance separately across all four domains.
• Focus more time on the 53% Application Development section.
• Recognize connections between code, data, and Business Manager settings.
• Practice debugging from symptoms and evidence.
• Compare safe extension patterns instead of editing base code.
• Understand why an option affects performance or security.
• Turn uncertain answers into small lab tasks.
• Build confidence with fresh scenarios rather than repeated memorization.

For each missed response, write down the official objective, the reason the selected option was wrong, the rule that supports the better option, and one practical task that confirms the concept.

Six-Week Salesforce B2C Commerce Developer Study Plan

Week 1: Blueprint, platform structure, and baseline

Read the official guide and create four sections in a study notebook. Take a short baseline assessment and record both incorrect and low-confidence answers.

Review sandboxes, instances, Business Manager, code versions, cartridges, WebDAV, site configuration, and storefront data assignments. Draw the relationship between code, configuration, data, and the shopper-facing site.

Week 2: Products, catalogs, inventory, prices, search, and content

Study the product data model, variations, categories, storefront catalogs, inventory lists, price books, product search, payment, shipping, Content Assets, Content Slots, folders, and Page Designer.

Create a troubleshooting checklist for a product that cannot be found, cannot be purchased, or displays the wrong price.

Week 3: Business Manager data and integrations

Focus on search preferences, refinements, sorting, logging, custom attributes, custom objects, caching, profiling, OCAPI permissions, and service configurations.

Complete a domain-focused practice set, then use documentation to review every uncertain response.

Week 4: SFRA application development

Spend the week on cartridges, ISML, controllers, routes, middleware, models, decorators, factories, helpers, Page Designer components, and localization.

Trace at least two shopper requests from route entry to response. Explain which code creates the model and which template renders the result.

Week 5: Security, performance, APIs, hooks, and jobs

Study forms, validation, CSRF protection, transactions, logging, service calls, hooks, caching, OCAPI, current SCAPI context, scheduled jobs, and custom job steps.

Review sample code for security and scalability risks. Explain how each risk could affect shoppers or production operations.

Week 6: Mixed practice and targeted repair

Take fresh mixed assessments under consistent conditions. Review results by domain instead of using only the total score. Return to the weakest objectives, complete a related hands-on task, and then attempt new questions.

Students can Find learning support for your career goals while building a final review list based on evidence from their practice results.

Hands-On Activities for Better Understanding

Deploy a simple cartridge

Create or inspect a small cartridge, confirm its directory structure, upload it to a sandbox code version, activate the version, and verify the cartridge path. Record what happens when the path order changes.

Import sample storefront data

Review an import package before running it. Identify the data type, identifiers, import mode, and dependencies. After the import, confirm the result in Business Manager and the storefront.

Trace a product-availability problem

Begin with a product that is not purchasable. Check catalog and category assignments, online status, price books, inventory, site configuration, and search indexing in a logical order.

Extend an SFRA controller safely

Study a base controller and decide whether the requirement should append, prepend, replace, or use a supporting hook or helper. Note the risk of duplicate side effects when a route performs an external call or write.

Build a protected form flow

Map the form definition, rendering, input validation, CSRF token, server-side processing, persistence, and error response. List the fields that must never be written to logs.

Design a service failure response

Choose a payment, tax, inventory, or address service. Define the timeout, safe logging, error path, retry or fallback behavior, and shopper message.

Review a performance problem

Find repeated object calls, large loops, unnecessary remote includes, service calls, or missing cache opportunities. State what evidence would show that the change improved performance.

Create a job runbook

For a catalog import or order export, document the schedule, file location, parameters, transaction boundaries, success status, error status, restart behavior, logging, and validation.

How to Review Practice-Test Results

Use four result categories:

• Correct with clear reasoning: The topic is probably strong.
• Correct but uncertain: Review it because the result may be a guess.
• Incorrect because knowledge is missing: Return to the official objective and source documentation.
• Incorrect because the scenario was misread: Identify the requirement or constraint that changed the answer.

Do not repeat the same assessment immediately. That mainly tests short-term memory. Study the weak topic, complete a practical activity, wait, and attempt a fresh or reshuffled set.

Common Preparation Mistakes

Ignoring the three smaller domains

Application Development is 53%, but code depends on the correct site, data, and Business Manager configuration. Cover all four domains.

Editing the base cartridge directly

Direct changes can make updates difficult and hide the boundary between Salesforce code and project code. Learn supported cartridge and controller-extension patterns.

Memorizing code without following the request flow

Understand how the route, middleware, model, helper, template, data, and response connect. That makes unfamiliar scenarios easier.

Using browser-side validation as the only protection

Client-side validation improves usability but can be bypassed. Important rules and CSRF checks must also be enforced on the server.

Logging too much information

More log data is not always better. Avoid secrets and shopper-sensitive data, and write messages that support a clear troubleshooting question.

Treating caching as automatically safe

Caching personalized, rapidly changing, or incorrectly scoped data can create functional or privacy problems. Decide what is safe to share and how fresh it must remain.

Confusing official scope with every new platform feature

Use the current Salesforce guide as the authority for certification domains. Study newer SCAPI and storefront developments as supplementary knowledge unless Salesforce adds them to the blueprint.

Reviewing only wrong answers

An uncertain correct response is still a knowledge gap. Mark confidence during practice and review guesses.

Readiness Checklist

A learner is approaching readiness when they can:

• Name all four official domains and percentages.
• Configure a sandbox development workflow and deploy cartridges.
• Explain why cartridge-path order matters.
• Import data and verify the result.
• Create a site and connect the required storefront data.
• Trace product visibility, price, inventory, search, and checkout issues.
• Explain Content Assets, Slots, Folders, and Page Designer.
• Configure search attributes, refinements, and sorting.
• Choose between a custom system-object attribute and a custom object.
• Use logs without exposing sensitive data.
• Explain OCAPI permissions and their least-access purpose.
• Describe how current SCAPI differs from the official OCAPI objective.
• Build and troubleshoot ISML templates and SFRA controllers.
• Explain models, decorators, factories, helpers, and middleware.
• Create reusable Page Designer components.
• Validate forms and apply CSRF protection.
• Implement localization across the required resources.
• Configure reliable service integrations.
• Use hooks without ignoring execution order and performance.
• Identify common scalability problems.
• Design scheduled jobs with safe transaction boundaries and recovery behavior.
• Explain why the selected solution is stronger than the alternatives.

Frequently Asked Questions

What are the current Salesforce B2C Commerce Developer topics?

The official outline contains B2C Commerce Setup at 11%, Work With a B2C Site at 12%, Data Management Using Business Manager Usage at 24%, and Application Development at 53%.

Which topic needs the most study time?

Application Development carries 53% of the blueprint. It includes ISML, controllers, models, Page Designer, forms, localization, logging, services, hooks, performance, OCAPI integrations, and jobs. Students should give it the most time while still covering the other domains.

Is Salesforce B2C Commerce Developer active in 2026?

Yes. Salesforce lists it in the current developer certification catalog. It is not marked for the February 2027 retirement that applies to Salesforce Certified B2C Commerce Architect.

Is B2C Commerce Developer the same as B2C Commerce Architect?

No. The Developer credential focuses on building and troubleshooting storefront functionality. The Architect credential focuses on higher-level global design decisions and is scheduled for retirement in February 2027. The Developer certification remains active.

Does a candidate need SFRA experience?

Yes, SFRA is central to the current developer guide. Candidates should understand cartridges, JavaScript controllers, models, ISML templates, middleware, forms, Page Designer, hooks, services, and jobs.

Is SCAPI included in the official blueprint?

The current official objectives explicitly name OCAPI Shop and Data APIs. Current Salesforce documentation also covers SCAPI extensively, so learning it is valuable for real projects. Candidates should not replace the official OCAPI objective with SCAPI when organizing certification study.

How much hands-on experience is recommended?

Salesforce describes the target candidate as having at least one year of general developer experience and three to six months in a B2C Commerce Developer role. Practical sandbox experience is strongly useful because the objectives involve configuration, code, deployment, data, and troubleshooting.

How should a student use practice questions?

Use a baseline set, domain-focused sets, and fresh mixed assessments. Review incorrect and uncertain responses. Connect each mistake to the official objective, verify it in documentation, and complete a related lab or code-review task.

How is the certification maintained?

Salesforce currently requires the B2C Commerce Developer maintenance badge. The maintenance schedule lists the Spring ’26 badge as available from April 23, 2026, with a due date of April 16, 2027. Credential holders should confirm their personal requirement on their Trailblazer profile.

Are these leaked Salesforce certification questions?

No. Ethical preparation uses independently written practice questions and mock tests based on public objectives and official documentation. It does not include copied, confidential, or leaked certification content. Candidates must follow the Salesforce Certification Program Agreement and code of conduct.