Make SaaS your own: Extending SitecoreAI and XM Cloud with the Sitecore Marketplace

How the Sitecore Marketplace for SitecoreAI lets you keep the upgrade safety of SaaS while extending the platform with apps, and why it's a game changer.

LinkedInNick Allen

Technical Director, 8x Sitecore MVP.

Futuristic dark-blue illustration of a SaaS dashboard in the centre, with glowing neon app tiles around it showing icons for AI, automation, integrations and puzzle-piece extensions, all connected with curved arrows to represent a marketplace of UI add-ons for XM Cloud / SitecoreAI.

Can a SaaS platform really adapt to the way my teams work?

At Sitecore Symposium, Dave Tilbury, Chief Operating Officer at Sitecore, framed a question that will feel familiar to any CIO or CMO looking at modern SaaS platforms:

How do I make SaaS my own?

If you’ve lived through the XM and XP era, you know what “making it your own” used to look like. On-premise and self-hosted Sitecore gave you near total extensibility. You could hook into almost any part of the platform, introduce new behaviours, and build up a library of intellectual property to roll from project to project.

That power came at a cost:

  • Heavy customisation made upgrades complex and risky.
  • You could not be sure a future platform release would tolerate what you’d done.
  • Every major upgrade meant auditing customisations and refactoring what no longer fit.
  • Even when you did create strong accelerators, moving them cleanly between projects was never frictionless.

XM Cloud changed that picture. As a SaaS offering, it removed the platform upgrade headache entirely: the product upgrades itself, new features arrive as they’re ready, and teams can rely on a stable, continuously evolving base.

But the first phase of XM Cloud had a different kind of gap: it was hard to safely bend the product around the specifics of your organisation without dropping back into old customisation patterns.

The Sitecore Marketplace for SitecoreAI exists to close that gap.

From custom everything to controlled extensibility

To understand why the Marketplace matters, it helps to look briefly at the three phases:

1. XM / XP (on-prem and hosted)

  • Almost unlimited customisation across the CMS.
  • Partners could build sophisticated starter kits and shared IP.
  • Upgrades were slow, risky and expensive precisely because of that flexibility.
  • Moving IP from project to project required packages, CLI extensions and a lot of care.

2. XM Cloud (first wave of SaaS)

  • The upgrade burden shifted to Sitecore.
  • Experience Accelerator (SXA) provides a module concept, but not something you could easily treat as a portable app ecosystem.
  • Extending the modern UI to support things like non-native DAMs or new field types was difficult without stepping outside recommended patterns.
  • Technically, you could still push the kind of customisations you used in XM/XP, but doing so would be an anti-pattern and undermine the benefits of SaaS.

3. XM Cloud with Sitecore Marketplace for SitecoreAI

  • You retain the upgrade safety of SaaS.
  • You gain a standardised, supported way to extend the platform.
  • IP becomes installable and shareable apps, not fragile custom code.

For technology and marketing leaders, the shift is subtle but crucial: from bespoke “projects” that are hard to move and maintain, to a governed extension layer that fits the SaaS lifecycle.

Sitecore Marketplace: extensibility without the upgrade tax

The Sitecore Marketplace for SitecoreAI gives you the best of both worlds:

  • A modern SaaS platform that upgrades on its own roadmap.
  • An app model that lets you introduce new capabilities without compromising that roadmap.

In practical terms, Marketplace becomes the hub where:

  • Sitecore ships first-party apps.
  • Partners and technology vendors publish vetted apps for general use.
  • Individual customers or partners deploy and selectively share their own private apps.

For organisations on XM Cloud, this is no longer “nice to have”. It’s becoming a central part of how you:

  • Tailor the authoring experience to your teams.
  • Integrate with systems Sitecore doesn’t connect to out of the box.
  • Experiment with AI-powered helpers that support your specific workflows.

You’re no longer waiting passively for the platform roadmap to catch up to your needs. You can extend responsibly, within a model designed to preserve the integrity of SaaS.

Two ways to extend: marketplace apps and custom apps

Within SitecoreAI, there are two key app types.

Public marketplace apps

These are apps built by:

  • Sitecore
  • Sitecore partners
  • Technology partners

They are:

  • Submitted to Sitecore.
  • Evaluated and reviewed.
  • Made available in the Marketplace for any SitecoreAI customer.

This gives you an “app store” of extensions you can browse, evaluate and install, knowing they’ve been through Sitecore’s review process and actively maintained.

Custom apps

Custom apps are where things become very interesting for individual organisations and partners.

  • They can be built by Sitecore customers or partners.
  • They are intended for use within a single organisation, or for a curated set of organisations you choose to share with.
  • They do not need to go through the public review process before use.
  • You can roll them out rapidly and make them available to your own tenants and projects.

For partners like Think Fresh. Digital, it also solves an old problem: once an app exists, moving that capability from project to project stops being a complex deployment story. It becomes a question of:

  • Who should have access to this app?
  • In which environments should it be installed?

Your IP becomes portable by design.

How extensions plug into the SitecoreAI experience

Under the hood, there are two main components that matter when you’re extending SitecoreAI and XM Cloud: App Studio and the Marketplace SDK.

App Studio: defining and configuring the app

App Studio lives inside the SitecoreAI portal. It’s where you:

  • Name your app and write a description.
  • Set up your publisher profile: logo, company details, what you do.
  • Choose an icon and basic visual identity for your app.
  • Decide where your app appears:
    • A full-page application within the portal.
    • A panel inside the Page Builder.
    • A custom field type.
    • Other extension points aligned to your use case.
  • Configure whether the app needs access to Sitecore APIs, and which permissions it requires.

Once configured, custom apps can be installed straight from your “My apps” section. Because they are not public, there’s no review delay: the configuration and installation steps are enough to get them into your environment.

At that point, they exist in the portal, but they don’t yet do anything. That’s where the code comes in.

Marketplace SDK: building the app experience

The Marketplace SDK is the toolkit your front-end code uses to interact with Sitecore. At a high level, it:

  • Works with any front-end framework that supports TypeScript.
  • Gives you access to the application context (where in the portal the app is running).
  • Exposes information about the current user and current page where relevant.
  • Integrates with additional SDKs such as the XM Cloud SDK to call product-specific APIs.

The pattern is consistent: as the Marketplace is expanded to other Sitecore SaaS products, each will offer SDKs that expose the right extension points for that product. You install the SDK for the product you’re extending and build from there.

Ready to turn SitecoreAI into a strategic advantage?

Think Fresh. Digital is a certified Sitecore partner with deep XM Cloud and SitecoreAI delivery experience. We’ll help you map how SitecoreAI fits into your roadmap.

Book a SitecoreAI consultation

A practical example: the “Content Companion” app

To make this concrete, let’s look at a simple use case we’ve been exploring at Think Fresh. Digital: a “Content Companion” app for XM Cloud Page Builder.

In the current Page Builder within SitecoreAI, content authors:

  • Navigate the site tree and search on the left.
  • Edit the current page visually on the right.

That works well, but it still assumes a fairly manual workflow when authors want to:

  • Jump between pages they have recently worked on.
  • Spot related pages that haven’t been updated in a while and might need attention.

The “Content Companion” idea is deliberately straightforward:

  • Introduce a slide-out panel within the Page Builder.
  • Populate that panel with:
    • Pages the current user has recently edited.
    • Pages that are relevant to the current one and may be due an update.

From an extension standpoint, this involves:

  • Defining the app in App Studio as a page context panel inside the Page Builder.
  • Using the Marketplace SDK hooks such as useAppContext and useMarketplaceClient to understand:
    • Which page is currently being edited.
    • Which user is currently working.

Let’s take a look at what that looks like from a development perspective:

const client = useMarketplaceClient();

const [isExpanded, setIsExpanded] = useState(false);
const [hostUser, setHostUser] = useState<UserInfo | undefined>(
  undefined
);

useEffect(() => {
  if (client) {
    // Make a query to retrieve the host user
    client
      .query("host.user")
      .then((res) => {
        setHostUser(res.data);
      })
      .catch((error) => {
        console.error("Error retrieving host.user:", error);
      });
  }
}, [client]);
  • Using the XM Cloud SDK to query:
    • Page-level context (IDs, languages, versions).
    • Field-level data such as metadata and keywords.
    • Components present on the page, where most of the content tends to live.

Here’s what it looks like to chain together the retrieval of the page context and more detailed information about the current page:

const client = useMarketplaceClient();

const appContext = useAppContext();

const [isExpanded, setIsExpanded] = useState(false);
const [isContentItemExpanded, setIsContentItemExpanded] = useState(false);
const [pageContext, setPageContext] = useState<PagesContext | undefined>(
  undefined
);
const [contentItem, setContentItem] = useState<
  Agent.ContentItemResponse | undefined
>(undefined);

const contextId = appContext?.resourceAccess?.[0]?.context?.preview as string;

useEffect(() => {
  if (client) {
    // Make a query to retrieve the page context
    client
      .query("pages.context", {
        subscribe: true,
        onSuccess: (data) => {
          setPageContext(data);
        },
      })
      .then((res) => {
        setPageContext(res.data);
      })
      .catch((error) => {
        console.error("Error retrieving pages.context:", error);
      });
  }
}, [client]);

useEffect(() => {
  if (client && pageContext?.pageInfo?.id) {
    client
      .query("xmc.agent.contentGetContentItemById", {
        params: {
          path: {
            itemId: pageContext.pageInfo?.id,
          },
          query: {
            language: pageContext?.pageInfo?.language,
            sitecoreContextId: contextId,
          },
        },
      })
      .then((res) => {
        setContentItem(res.data?.data);
      })
      .catch((error) => {
        console.error(
          "Error retrieving xmc.agent.contentGetContentItemById:",
          error
        );
      });
  }
}, [client, pageContext, contextId]);

In this example, the fetching of page data depends on the XM Cloud SDK, which requires us to send additional parameters in the request to ensure we are fetching data with the correct contextId.

Some of these queries require additional API permissions, which are configured back in the App Studio definition for the app.

The result is an authoring helper that:

  • Lives natively in the SitecoreAI interface.
  • Looks and feels like part of the product thanks to the Blok design system.
  • Addresses a tangible authoring problem: “what should I work on next, and how do I move there quickly?”
The XM Cloud Page Builder interface with a slide-out panel showing data about the current page being edited.

It’s not about AI for its own sake. It’s about using the Marketplace to bring targeted, value-driven capabilities into the day-to-day workflow.

Choosing the right app architecture for your use case

Not every idea needs the same depth of architecture. The Marketplace supports two broad approaches.

Client-side apps

Client-side apps are ideal when you:

  • Only need UI logic and lighter interactions.
  • Are not making complex server-to-server calls.

In this model:

  • Authorisation is handled for you by the platform.
  • You focus on the front-end behaviour and how it interacts with the Marketplace and product SDKs.

This fits many author experience enhancements, including the “Content Companion” style of panel.

Full-stack apps

Full-stack apps come into play when:

  • You need more sophisticated logic.
  • You’re integrating multiple services.
  • Many AI-powered workflows fall into this category.

They give you both client-side and server-side capabilities, at the cost of:

  • Implementing explicit authorisation (for example, using Auth0).
  • Managing more moving parts in your architecture.

The guiding principle is simple:

  • Start with the business problem.
  • Choose the simplest architecture that can still deliver it.
  • Move to full-stack only where the complexity genuinely requires it.

We’ll explore authorisation and full-stack patterns in more depth in a separate piece.

From idea to working app: a high-level journey

In practice, taking an idea from concept to working Marketplace app follows a clear flow:

1. Identify a tangible business problem

Examples include:

  • Analysing a page for AEO/SEO readiness.
  • Checking sentiment and brand consistency.
  • Providing a picker for a third-party DAM that Sitecore doesn’t natively integrate with.
  • Introducing new, value-adding field types.

2.Pick your extension surface

Decide where the capability belongs:

  • A full-page app in the SitecoreAI portal.
  • A panel inside Page Builder.
  • A custom field type within the CMS interface.
  • Another extension point aligned to your scenario.

3. Configure your app in App Studio

  • Set up metadata, publisher profile and icon.
  • Choose extension points.
  • Define which APIs and permissions you require.

4. Install your custom app

  • As a custom app, it can be installed straight from your “My apps” section.
  • No public review, so you can iterate quickly.

5. Scaffold with Sitecore tooling

Sitecore provides boilerplate templates to scaffold an app based on your chosen architecture and stack (including options for different Next.js versions and mono-repo setups). These templates include integration with Blok, Sitecore’s design system for Marketplace apps.

Blok gives you:

  • A set of components that visually align with the Sitecore interface.
  • Applications that look and feel like they belong in the product.

6. Build and test with the Marketplace SDK docs

Sitecore maintains two key documentation portals:

  • One focused on App Studio and app configuration: app types, architectures, and configuration steps.
  • One focused on the Marketplace SDK itself: quick starts, examples, and detailed reference documentation.

Together, they support both the configuration and coding sides of app development.

7. Iterate based on author feedback

Once the first version is in the hands of real users, the most useful signal comes from content authors and marketers themselves. The Marketplace model makes it easier to iterate without destabilising the core platform.

Why this matters to CIOs and CMOs

From a distance, it’s easy to see the Marketplace as just another developer feature. In reality, it addresses core concerns for both technology and marketing leadership.

For CIOs and technology leaders

  • Governed extensibility: Apps have explicit permissions, defined extension points, and clear ownership.
  • Upgrade-safe customisation: The platform can evolve on its own timeline while your extensions remain insulated from breaking changes.
  • Reusable IP: Extensions become assets you can move between business units, projects and markets, not one-off custom work lost in a codebase.

For CMOs and marketing teams

  • Faster access to tailored tools: You can shape the authoring experience around how your teams actually work, rather than working around the product.
  • Embedded intelligence: AI-driven helpers live inside the CMS, where content is created and managed, instead of in disconnected tools.
  • Responsiveness to change: When new channels, formats or internal processes emerge, you don’t have to wait for the product roadmap. You can extend the platform responsibly through apps.

SitecoreAI beyond the Marketplace: a composable extension stack

The Marketplace is one part of a broader SitecoreAI story about customising SaaS safely.

Alongside Marketplace apps, you have:

  • Sitecore Connect – a set of pre-built connectors powered by AI, helping you integrate with external systems.
  • Sitecore Studio – a way to configure and orchestrate agents that perform tasks for both technical and marketing users.
  • MCP server – a mechanism to automate work and build applications outside the Sitecore portal, including desktop tools or IDE plug-ins that still act on the CMS in a no vendor lock-in model.

Together, they form a composable toolkit for SaaS customisation:

  • Marketplace for UI and in-product extensions.
  • Connect for integrations.
  • Studio and MCP for automation and agents.

It’s a stack designed to let you shape the platform around your organisation, rather than reshaping your organisation around the platform.

Conclusion: SaaS, but on your terms

Returning to the original question – “how do I make SaaS my own?” – the Sitecore Marketplace for SitecoreAI offers a clear answer:

  • Keep the benefits of a modern SaaS CMS: continuous upgrades, stability, and a strong core roadmap.
  • Add an extension model that is safe, governed and portable.
  • Use apps to bring AI and automation into the heart of the authoring experience, solving specific, high-value problems.

At Think Fresh. Digital, we see Marketplace as a strategic layer, not a side feature. It’s where your ideas turn into concrete capabilities that can move faster than your internal roadmap, without sacrificing the fundamentals that made you choose SaaS in the first place.

Nick Allen
LinkedIn

Nick Allen

Technical Director, 8x Sitecore MVP.

Related articles

Exploring your options?

We’re here to help you think through what’s possible, at any stage of your project.

Start the conversation
Back to Insights

FAQs

Sitecore Marketplace and SitecoreAI FAQs

The Sitecore Marketplace for SitecoreAI is an app ecosystem that lets you extend XM Cloud and other Sitecore SaaS products with installable apps. These apps can add new UI panels, custom field types, integrations and AI-powered helpers without modifying the core platform. It is designed to give you a governed way to customise SaaS while keeping the benefits of automatic upgrades.

The Sitecore Marketplace extends XM Cloud by providing safe extension points inside the SitecoreAI portal and Page Builder. Apps registered through App Studio and built with the Marketplace SDK can appear as full-page tools, panels or custom fields that work directly with XM Cloud data. This means you can tailor the authoring experience and add new capabilities without writing fragile customisations against the core CMS.

Public marketplace apps are created by Sitecore, partners and technology vendors, reviewed by Sitecore and made available for any SitecoreAI customer to install. Custom apps are built by individual organisations or partners for their own tenants or selected customers, without going through the public review process. Both use the same Marketplace patterns, but custom apps are focused on private IP and very specific business needs.

Sitecore Marketplace apps interact with SitecoreAI and XM Cloud through supported APIs and SDKs rather than direct changes to the platform. App permissions and extension points are defined in App Studio, so Sitecore can evolve the SaaS product while keeping those contracts stable. This separates your custom logic from the core CMS and protects your upgrade path.

Marketers use Sitecore Marketplace apps to speed up everyday work in the CMS. Examples include apps that surface related pages to update, run AEO or SEO checks on a page, analyse sentiment and brand tone, or connect to a third-party DAM from inside Page Builder. Because these apps live in the SitecoreAI interface, they improve productivity without forcing authors into separate tools.

Choose a client-side Sitecore Marketplace app when you mainly need UI behaviour and lightweight interactions that run in the browser. Choose a full-stack app when you need server-side logic, complex integrations or advanced AI workflows that call external services. A good rule is to start with the simplest client-side option and move to full-stack only when your use case genuinely requires it.

SitecoreAI is the wider platform that underpins the Marketplace, Sitecore Connect, Sitecore Studio and MCP server. Marketplace apps extend the UI, Connect handles integrations, Studio orchestrates agents and MCP automates work inside and outside the CMS. Together they form a composable SitecoreAI stack for customising SaaS safely.

Think Fresh Digital helps organisations design a SitecoreAI roadmap, identify high-value Marketplace app ideas and choose the right architecture for each use case. We work with your teams to prototype and build apps, wire them into XM Cloud and establish governance so extensions remain supportable. The goal is to turn SitecoreAI into a strategic advantage, not just a collection of features.