Commerce Core overview

Current version: 9.2

The following table describes the concepts of Commerce Core:




An internal construct that wraps a specific set of work for activity tracking, for example, for reporting and performance. The solution implements this as a CommandActivity all commands are wrapped in an activity to enable performance reporting on the command.

A TrackActivityPipelineis executed when the activity is complete, which enables a plugin to take action.

An example of an activity is to monitor performance of an action against an SLA and report actions outside the SLA, or to generate an alert.


Basic approval commands and pipelines to facilitate a basic approval process. Approvals are used by pricing and promotions to seek the approval of changes before implementing.


The ability to authenticate a call to the service API using certificates.


Commands and pipelines to support bootstrapping the solution. The BootstrapPipeline loads environment configurations from the wwwroot/data/environments folder into the SitecoreCommerce_Global database. After bootstrapping, those environment configurations do not need to be present. Any subsequent environment configuration is retrieved from the database during normal runtime operations.


Commands and pipelines to support in-memory caching. This provides the ability to have environment-specific caching, to specify cache priorities, and to clear the cache. Caching functionality, in turn, leverages the Sitecore.Framework.Caching functionality for the actual caching.


Basic structure for supporting the concept of commands. A command acts like the API in a task-driven API.


Basic structure for supporting compositional extensibility, including the component class and various base components.


A call-level context called CommerceContext, which is initialized when a call enters the service and is carried throughout the service call. The CommerceContext provides an object cache, messaging, headers, and other core call-level information.


Basic controllers that make core functionality available through the Service API.


Custom JSON converters for the Service API.


Commands, policies, and pipelines to support reading and writing commerce entities. A CommerceEntity is a core artifact designed to directly represent a business concept, which is stored as a single unit in a persistent storage. Entities have identifiers and can be retrieved through the Service API.


Commerce environments provide the ability to have separately configurable pools of data and service functionality that run together in a single-service instance. Environments can share the same persistent store as other environments or be separated into their own exclusive persistent store.


Basic infrastructure to support events and event-driven actions.


Basic CommerceException base class.


Commands and their pipelines to support globalization, including support for multicurrency and localization.


Commands and pipelines to support basic list functionality, including basic list management. Use ManagedLists to track lists of entities either based on their state or based on activities that need to be performed on them. Lists are used to provide organizational structure and to support business processes.


Commands and pipelines to support locations, for example, retrieving supported countries and country information.


Support for core logging using SeriLog and to specify logging using Microsoft Application Insights.


Core classes to support media types and policies, including a GlobalImagePolicy and an image class.


Commands and pipelines to support minions including the MinionBoss and RunMinion pipelines, and the policies to support configuring minions in the environment configuration.


Basic core models, which are POCO classes that are reusable inside entities and components. Models can be used to present data as part of a command response, in the models collection.

Models are listed in the Sitecore.Commerce.Documentation.chm (in the SDK folder) on the Model class page.


A node is a running instance of the Service API. Core pipelines, blocks, and policies that enable basic node functionality.


Commands and policies to support tracking and integrating with performance counters for commands.


Core commands and models to support pipeline functionality. Pipelines, in turn, leverage the Sitecore.Framework.Pipelines infrastructure.


Core support for the Commerce pluggable extensibility.


A named, versionable and variable set of data that can be used as facts within behaviors to influence behavioral outcomes. This provides an auditable mechanism for viewing, simulating, and changing core decision criteria that might be used by business processes or other policy-driven behavior. Various plugins have specialized policies to add additional facts to existing policies and/or new policies, or to implement new concepts, such as dynamic pricing.

Policy characteristics include:

  • Centralized policy store using abstract entity storage.

  • Worker processes only need a link to the policy store to bootstrap.

  • Single point of truth for policies.

  • Publish workflow without moving data.

  • Policies are heavily cached and rarely change.

  • Policies can have attached rules to deliver personalized policies.

Policies are listed in the Sitecore.Commerce.Documentation.chm (in the SDK folder) on the Policy class page.


Core interfaces for an EntityProvider and an IndexProvider. The concept of a provider is avoided because any plugin could potentially be a provider. This is only used by the FileSystemProvider, which enables reading a CommerceEntity from the file system.


Core models and policies to enable the basic Service API.


Core functionality to support transactionality in the solution.

Do you have some feedback for us?

If you have suggestions for improving this article,