For years, “Salesforce B2C Commerce integration” usually meant one word sooner or later:
cartridge.
Install it. Add it to the path. Import metadata. Configure services. Merge storefront templates. Wire the front end. Document the upgrade sequence. Hope the next storefront release does not turn the integration into another mini implementation.
Salesforce’s new Commerce Apps framework does not make cartridges disappear.
It does something more interesting.
It turns the pieces around a B2C extension into a formal, installable package.
Salesforce calls that package a Commerce App Package, or CAP. A CAP can bundle Storefront Next UI extensions, backend cartridges, custom APIs, IMPEX data and guided app configuration into one deployable unit. Public ISV apps can be published through a centralized registry and discovered by merchants in Business Manager; systems integrators can also build private merchant-specific apps that use the same framework without being publicly listed.
That is a bigger architectural change than “a new app marketplace.”
The old problem was never just installing code
B2C Commerce has had a healthy partner ecosystem for years.
The difficult part is that an extension often crosses several surfaces at once.
A payments integration has backend service logic, credentials, checkout UI, webhooks and Business Manager configuration.
A ratings product may need product-page components, category-card stars, server-side APIs, custom attributes, moderation configuration and external scripts.
A tax engine has hooks, service definitions, site preferences, data and operational settings.
A marketplace or OMS connector may need APIs, jobs, order hooks and merchant configuration without owning much storefront UI at all.
Historically, vendors and implementation teams packaged those concerns in different ways.
That variability creates implementation work.
Salesforce is now trying to formalize the contract.
A Commerce App is not a replacement for all cartridges
This distinction matters.
Salesforce’s developer documentation describes Commerce Apps as an evolution of the cartridge model, not a deletion of it.
A Commerce App can still contain backend cartridges.
It can also contain no cartridge at all.
Salesforce currently documents three architectural patterns.
The first is UI-only.
The platform or another service already provides the backend capability, and the Commerce App contributes Storefront Next components, routes, hooks or data providers.
The second is backend-only.
Salesforce defines an extension-point contract and the app implements the backend logic through cartridges or APIs while the platform supplies the storefront experience.
The third is full stack.
The app owns both the Storefront Next extensions and the backend integration.
That flexibility is important because an app framework becomes brittle if every partner is forced into the same technical shape.
The real unit of delivery is becoming the package
This is the part merchants should pay attention to.
A traditional cartridge tells you that code exists.
A package can describe much more of the installation.
Frontend extension points.
Backend hooks.
Configuration tasks.
IMPEX data.
Custom API surfaces.
Dependencies.
Installation metadata.
The intended outcome is a Business Manager experience where merchants can discover, install and configure native or partner solutions with much less hand assembly.
So this is no longer only an ISV packaging idea.
Salesforce itself is using the model to ship commerce capability.
Storefront Next is what makes the frontend side interesting
The packaging story is tightly connected to Storefront Next.
Storefront Next provides extension targets where an app can place React components into defined parts of the experience instead of requiring a merchant to merge a vendor’s storefront implementation manually.
That is strategically important for the partner ecosystem.
A review vendor should not need to understand every merchant’s React application before it can render a star rating.
A payments provider should not need every implementation team to invent a different integration pattern.
A shipping app should not need to own the entire checkout simply to expose a delivery estimate.
Standard targets can reduce that surface area.
But “standardized extension point” should not be confused with “zero integration.”
Click-to-install does not remove architecture responsibility
This is where enterprise teams should remain skeptical.
A package can automate installation.
It cannot decide your operating model.
Before installing a Commerce App, a merchant should still know:
What external system becomes authoritative?
What customer, order or product data leaves Salesforce?
Where are credentials stored?
What runs synchronously in the shopper path?
What happens when the third-party service is slow?
What happens when it is unavailable?
Which data remains after uninstall?
How is the app versioned?
Can a release be rolled back independently of the storefront?
What is Salesforce-supported versus vendor-supported?
What must still be customized for the merchant?
Those questions do not disappear because Business Manager gained an Install button.
In fact, a good app framework should make them easier to answer.
The framework may expose weak partner products faster
There is another consequence for ISVs.
When installation becomes standardized, differentiation moves elsewhere.
The vendor can no longer rely on “we have a Salesforce cartridge” as the entire integration story.
Merchants can ask harder questions.
How complete is the package?
Does it support Storefront Next properly?
Does it use platform extension points where they exist?
Does it require template-level customization outside the package?
How much external JavaScript is loaded?
Does the backend fail open or fail closed?
Can the implementation be promoted through environments consistently?
Does uninstall actually restore the previous state?
How are upgrades tested?
That is healthy pressure.
Packaging should make operational quality more visible, not less.
Public apps and private apps solve different problems
Salesforce has also made a useful distinction between public and private Commerce Apps.
Public ISV apps can use the Commerce App Registry and become discoverable to merchants through Business Manager.
Private apps can be created for a specific merchant by an SI or internal engineering team and installed without appearing in the public catalog.
That matters because enterprise commerce is full of integrations that should never become marketplace products.
A retailer may have a proprietary loyalty service.
A regional payment adapter may be relevant to one operating company.
A manufacturer may need a private ERP handoff.
A merchant may want to package its own reusable storefront capability consistently across brands.
The same packaging discipline can still help.
Existing SFRA and cartridge estates are not suddenly obsolete
This is the sentence I would want to see in every discussion of Commerce Apps.
Salesforce B2C Commerce still supports existing storefront models and cartridge-based implementations.
Commerce Apps do not automatically modernize an SFRA estate.
They do not migrate custom code to Storefront Next.
They do not convert years of merchant-specific integration logic into clean extension points by themselves.
And a new Commerce App does not mean a third-party dependency has become simple.
The framework creates a better delivery contract for new and modernized extensions.
That is valuable enough without pretending the old world vanished overnight.
What should merchants ask vendors now?
If you are evaluating a B2C Commerce extension in 2026, “Do you have a cartridge?” is no longer a sufficient technical question.
Ask:
Do you have a Commerce App Package, and what exactly is inside it?
Then go deeper.
Which storefronts are supported?
Which extension points are used?
Which backend cartridges remain?
Which custom SCAPIs are introduced?
Which IMPEX objects or preferences are created?
What external scripts are loaded?
What is the upgrade and rollback model?
What is left behind if the app is removed?
What still requires an SI?
That is the real promise of the Commerce Apps framework.
Not that commerce extensions become magically simple.
That their implementation surface can become explicit, repeatable and inspectable.
For merchants, that could reduce the hidden integration tax.
For ISVs, it raises the bar.
And for Salesforce B2C Commerce, it may be the missing packaging layer Storefront Next needed if the new storefront is going to support a serious enterprise app ecosystem.
