Sitecore has made a significant shift towards a fully API-first, headless-friendly architecture. This modern approach decouples content management from delivery, giving developers unprecedented flexibility to work with content from virtually anywhere—be it front-end applications, backend systems, integration services, or automated pipelines.

One of the biggest advantages of this shift is that you no longer need server-side access to Sitecore to manipulate content. Instead, the system exposes a robust set of APIs to support these powerful new use cases.

Sitecore provides three key APIs, each designed for a specific purpose: Experience Edge APIs, Authoring and Management API. Understanding how these APIs relate and differ is crucial for designing robust external integrations, building sync services, and managing your content programmatically.

This blog will  provide a practical, end-to-end view of how these APIs fit into modern architectures. We will specifically walk through how any external system can call the Authoring API using GraphQL,  how to execute common GraphQL mutations such as create, update, delete, rename, and move. If you’re building integration services or automation pipelines for SitecoreAI, this will give you a complete picture of what’s possible

Sitecore’s modern architecture separates content operations into three distinct API layers. This crucial separation is designed to ensure scalability, security, and clear responsibility boundaries across the content lifecycle.

Let’s break down the purpose and typical use case for each API:

1. Experience Edge Delivery API

The Experience Edge Delivery API is Sitecore’s public-facing endpoint, dedicated purely to high-performance content delivery.

• Primary Use: Used primarily by your front-end applications (ex- Next.js, React, mobile apps) and kiosks to fetch published content for your presentation layer.

• Core Function: It is fundamentally read-only and does not support content creation or modification.

• Interface: Exposes a GraphQL endpoint that allows for querying items, fields, and components efficiently.

• Authentication: Requires minimal or no complex authentication (often just an API key) when fetching published content, as it is designed for global, low-latency access.

• Endpoint: https://edge.sitecorecloud.io/api/graphql/v1

2. Authoring API (GraphQL)

The Authoring API is the control center for all item-level content management operations from external systems.

• Primary Use: This is the API you use when building integration pipelines, external systems or third-party applications that need to manipulate content programmatically.

• Core Functions: It allows external systems to perform the same operations authors execute in the CMS UI, including:

  • Create, update, and delete items.

  • Rename or move items.

  • Manage media assets.

  • Work with workflows and language settings.

• Interface: Exposed through a dedicated GraphQL endpoint that supports both queries and mutations.

• Authentication: All calls must be authenticated. The recommended secure approach is using OAuth’s client_credentials flow to obtain a Bearer JWT access token, as detailed in Sitecore’s security documentation.

• Endpoint Structure: The endpoint is hosted on your Content Management (CM) instance, following a structure like:
  https://your-cm-instance/sitecore/api/authoring/graphql/v1

3. Management API

The Management API supports all administrative, system, and environment-level capabilities.

• Primary Use: Often used in CI/CD pipelines, server-side processes, and automated scripts for environment maintenance.

• Core Functions: These include operations that affect the system state or background jobs, such as:

  • Triggering content publishing jobs.

  • Running index rebuilds.

  • Managing environment metadata and background jobs.

  • Generating access tokens (such as through the client_credentials flow).

• Interface: It shares the same GraphQL endpoint as the Authoring API.

• Endpoint: same as Authoring API.
  Note: The distinction between the Authoring and Management API is primarily managed by the OAuth scopes assigned to the access token used for authentication, not by a different URL.

• Relationship to Authoring: While it doesn’t handle item-level content edits, it works alongside the Authoring API to support a full content lifecycle, such as writing content (Authoring API) followed by publishing it (Management API).

Enabling the Authoring and Management APIs: The Prerequisites

Before we can send our first GraphQL mutation to manage content, we have to handle the setup and security. The prerequisites for enabling the Authoring and Management APIs are slightly different depending on your Sitecore environment, but the end goal is the same: getting a secure access token.

Sitecore XM Cloud / SitecoreAI

If you’re on a cloud-native platform like XM Cloud or SitecoreAI, the GraphQL endpoints are already up and running. You don’t have to fiddle with configuration files. Your main focus is on authorization:

1. Generate Credentials: You need to use the Sitecore interface (often in the Manage or Connect section) to generate a set of Client Credentials (a Client ID and a Client Secret). These are your secure “keys” to the content.

2. Define Scopes: When you generate these credentials, you must ensure the associated identity has the appropriate OAuth scopes. For instance, you’ll need scopes like sitecore.authoring and sitecore.management to be included in your token request. This is what tells the system what your application is actually allowed to do (read, write, or publish).

Sitecore XM /XP

For traditional, self-hosted Sitecore XM installations, you have a small administrative step to get the endpoints operational:

1. Enable the Endpoint: You need to deploy a simple configuration patch file. This patch explicitly enables the API endpoint itself and often the helpful GraphQL Playground IDE (for easy testing). You’ll typically set configuration settings in your CM instnace.

   <setting name="GraphQL.Enabled" value="true" /> <setting name="GraphQL.ExposePlayground" value="true" />

2. Configure Identity Server: Similar to XM Cloud, you then need to register your client application with your Sitecore Identity Server. This involves creating a client record in your IDS configuration that specifies the required allowedGrantTypes (like client_credentials) and the necessary allowedScopes (sitecore.authoring, etc.).

Whether you’re in the SitecoreAI or Sitecore XP/XM the biggest hurdle is obtaining that secure JWT Bearer token. Every request you send to the Authoring and Management APIs must include this token in the Authorization header. We’ll dive into the client_credentials flow for getting this token in the next section.

For the absolute definitive guide on the steps specific to your environment, always check the official documentation: Sitecore XM Cloud / SitecoreAI and Sitecore XP/XM.

Authoring API – Authentication, Requests, and Query Examples

The Authoring API exposes the full set of content-management capabilities through GraphQL. Because these operations can modify items, media, workflows, and other critical pieces of the content tree, every request must be authenticated. The Authoring API uses OAuth, and the recommended approach is the client_credentials flow.

To authorize a request, you first create a client in the Sitecore Cloud Portal. This client gives you a client_id and client_secret. Once you have them, you request an access token from the token endpoint:

POST https://auth.sitecorecloud.io/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials
client_id=your_client_id
client_secret=your_client_secret
audience=https://api.sitecorecloud.io

The response contains an access_token and an expiry. This token is then passed in the Authorization header for all subsequent GraphQL calls.

The Authoring API endpoint accepts only POST requests with a JSON body containing a GraphQL query or mutation. A typical request looks like this:

POST https://your-tenant.sitecorecloud.io/api/authoring/graphql
Authorization: Bearer your_access_token
Content-Type: application/json

mutation CreateItem(
  $name: String!
  $parentId: ID!
  $templateId: ID!
  $fields: [FieldValueInput]!
) {
  createItem(
    input: {
      name: $name
      parent: $parentId
      templateId: $templateId
      fields: $fields
    }
  ) {
    item {
      ItemID: itemId
      ItemName: name
    }
  }
}

Input Variables:

{
    name = <item-name>,
    parentId = <parent-item-id>,
    templateId = <template-id>,
    fields = [
        { name: "title", value: "Contact US" }
        { name: "text", value: "Contact US Here" }
      ]
};

mutation UpdateItem(
  $id: ID!
  $database: String!
  $language: String!
  $fields: [FieldValueInput!]
) {
  updateItem(
    input: {
      itemId: $id
      database: $database
      language: $language
      version: 1
      fields: $fields
    }
  ) {
    item {
      ItemID: itemId
      ItemName: name
    }
  }
}


Input Variables:
{
    id = <item-id>,
    database = "master",
    language = "en" ,
    fields = [
        { name: "Title", value: "New Title" }
        { name: "Content", value: "New Content" }
      ]
};

mutation RenameItem(
  $id: ID!, 
  $database: String!,
  $newName: String!
) {
  renameItem(
    input: {
      itemId: $id,
      database: $database, 
      newName: $newName 
  }
) {
    item {
      ItemID: itemId
      ItemName: name
    }
  }
}

Input Variables:
{
     id = <item-id>,
     database = "master",
     newName = <new-item-name>
};

mutation MoveItem($id: ID!, $targetParentId: ID!) {
  moveItem(input: { itemId: $id, targetParentId: $targetParentId }) {
    item {
      ItemID: itemId
      ItemName: name
    }
  }
}

Input Variables:
{
    id = <item-id>,
    targetParentId = <target-parent-item-id>,
};

mutation DeleteItem($itemID: ID!) {
  deleteItem(input: { itemId: $itemID, permanently: false }) {
    successful
  }
}

Input Variables:
{
itemID = <item-id>,
};

These mutations are extremely powerful because they give you full authoring control from any external system. You can build automated pipelines, sync content from third-party sources, integrate back-office systems, or maintain content structures without needing direct access to the CMS. The Authoring API essentially opens up the same level of control Sitecore developers traditionally had through server-side APIs, but now in a clean, modern, and fully remote GraphQL form.

Management API  – Authentication and Usage

The Management API sits alongside the Authoring API but focuses on administrative and system-level operations. These include running indexing jobs, publishing content, listing background jobs, working with workflows, or inspecting environment metadata. The authentication model is the same: you obtain an access token using the same client_credentials flow and include it in the Authorization header when making requests.

The Management API also uses GraphQL, though the endpoint is different. The requests still follow the same structure: POST calls with a JSON body containing the GraphQL query or mutation.

A typical request looks like:

POST https://your-tenant.sitecorecloud.io/api/management/graphql
Authorization: Bearer your_access_token
Content-Type: application/json

A common example is triggering a publish operation. The mutation for that might look like:

mutation PublishItem($root: ID!) {
  publishItem(
    input: {
      rootItemId: $root
      languages: "en"
      targetDatabases: "experienceedge"
      publishItemMode: FULL
      publishRelatedItems: false
      publishSubItems: true
    }
  ) {
    operationId
  }
}

Input Variables:
 {
     root = <iten-to-publish>
 };

The Management API is often used after content changes are made through the Authoring API. For example, after creating or modifying items, your external service may immediately trigger a publish so that the changes become available through Experience Edge.

The authorization workflow is identical to the Authoring API, which keeps integration straightforward: your service requests one token and can use it for both Authoring and Management operations as long as the client you registered has the appropriate scopes.

Experience Edge Delivery API –  Authentication and Query Examples

Experience Edge exposes published content through a globally distributed read-only API. Unlike the Authoring and Management APIs, the Delivery API uses API keys rather than OAuth tokens for content retrieval. However, the API key itself is obtained through an authenticated request that also uses an access token.

To get the Experience Edge API key for a specific environment, you first authenticate using the same client_credentials flow. Once you have your access token, you call the Deploy or Environment API endpoint to generate or retrieve an Edge Access Token or Delivery API key for that specific environment. This token is what your application uses when querying Edge.

Once you have the key, requests to Experience Edge look more like this:

POST https://edge.sitecorecloud.io/api/graphql/v1
X-GQL-Token: your_edge_api_key
Content-Type: application/json

A basic read query might be:

query ItemExists($id: String!, $language: String!) {
  item(path: $id, language: $language) {
    ItemID: id
    ItemName: name
  }
}

Input Variables:
{
   id= <item-id>,
   language = "en"
}

1. Obtain access token
2. Use token to retrieve or generate the Edge API key
3. Use the Edge key in all Delivery API requests
4. Query published content through GraphQL

Making Sense of the Entire Flow

With the combination of Experience Edge for delivery and the Authoring and Management APIs for write and operational tasks, Sitecore has opened up a model where external systems can participate directly in the creation, maintenance, and publication of content without ever touching the CM interface. This gives developers and teams a lot more freedom. You can build sync services that keep Sitecore aligned with external data sources, migrate content with far less friction, or automate repetitive authoring work that used to require manual effort. It also becomes straightforward to push structured data such as products, locations, events, or practitioner information – into Sitecore from CRMs, commerce engines, or any internal system you rely on. Everything is just an authenticated GraphQL call away.

The separation between these APIs also brings clarity. The Authoring API handles the content changes, the Management API supports the operational steps around them, and Experience Edge takes care of delivering that content efficiently to any front end. Each piece has its own responsibility, and they work together without getting in each other’s way. Authors continue working in the CMS. Front-end applications consume only published content. Integration services run independently using APIs built for automation.

The end result is a content platform that fits naturally into modern technical ecosystems. It’s cloud-friendly, headless from the ground up, and flexible enough to integrate with whatever tools or systems an organization already uses. And because everything runs through secure, well-defined APIs, you get consistency, stability, and a workflow that scales as your requirements grow.

This unified approach – external content operations through Authoring and Management APIs, and high-performance delivery through Experience Edge, is what makes the platform genuinely powerful. It lets you build reliable, maintainable, and future-ready content solutions without being tied to the internals of the CMS, and that is a significant shift in how we think about managing content today.

Content chaos is costing you more than you think

Every disconnected asset, every redundant workflow, every missed opportunity to reuse content adds up, not just in operational inefficiency, but in lost revenue, slower time-to-market, and diminished brand consistency. For many organizations, the content supply chain is broken, and the cracks show up everywhere: marketing campaigns delayed, creative teams overwhelmed, and customers receiving fragmented experiences.

Sitecore Content Hub can help solve this, but here’s the truth: technology alone won’t solve the problem. Success requires a strategic approach that aligns people, processes, and platforms. Over the years, I’ve seen one principle hold true: when you break the process into digestible steps, clarity emerges. Here’s the five-step framework I recommend for leaders who want to turn Content Hub into a competitive advantage. It’s what I wish I had before my first implementation. While Content Hub is extremely powerful for a Digital Asset Management (DAM) platform, and there could be entire books written on each configuration point, my hope in this post is to give someone new to the platform a mindset to have before beginning an implementation.

Step 1: Discover and Decode

Transformation starts with visibility. Before you configure anything, take a hard look at your current state. What assets do you have? How do they move through your organization, from creation to approval to archival? Who touches them, and where do bottlenecks occur?

This isn’t just an audit; it’s an opportunity to uncover inefficiencies and align stakeholders. Ask questions like:

• Are we duplicating content because teams don’t know what already exists?
• Where are the delays that slow down time-to-market?
• Which assets drive value and which are digital clutter?

Document these insights in a way that tells a story. When leadership sees the cost of inefficiency and the opportunity for improvement, alignment becomes easier. This step sets the foundation for governance, taxonomy, and integration decisions later. Skip it, and everything else wobbles.

Step 2: Design the Blueprint

Once you know where you are, define where you’re going. This is your architectural phase and the moment to design a system that scales.

Start with taxonomy. A well-structured taxonomy makes assets easy to find and reuse, while a poor one creates friction and frustration. Establish naming conventions and metadata standards that support searchability and personalization. Then, build a governance model that enforces consistency without stifling creativity.

Finally, map the flow of content across systems. Where is content coming from? Where does it need to go? These answers determine integration points and connectors. If you skip this step, you risk building silos inside your new system, which is a mistake that undermines the entire investment.

Step 3: Deploy the (Content) Hub

See what we did there?! With the blueprint in hand, it’s time to implement. Configure the environment, validate user roles, and migrate assets with care.

Deployment is more than a technical exercise. It’s a change management moment. How you roll out the platform will influence adoption. Consider a phased approach: start with a pilot group, gather feedback, and refine before scaling.

Testing is critical. Validate search functionality, user permissions, and workflows before you go live. A smooth deployment isn’t just about avoiding errors. It’s about building confidence across the organization.

Step 4: Drive Intelligent Delivery

Content Hub isn’t just a repository; it’s a strategic engine. This is where you unlock its full potential. Enable AI features to automate tagging and improve personalization. Create renditions and transformations that make omnichannel delivery seamless.

Think beyond efficiency. Intelligent delivery is about elevating the customer experience. When your content is enriched with metadata and optimized for every channel, you’re not just saving time. You’re driving engagement and revenue.

Governance plays a starring role here. Standards aren’t just rules. They’re the guardrails that keep your ecosystem healthy and scalable. Without them, even the smartest technology can devolve into chaos.

Step 5: Differentiate

This is where leaders separate themselves from the pack. Implementation is not the finish line—it’s the starting point for continuous improvement.

Differentiation begins with measurement. Build dashboards that show how content performs across channels and campaigns. Which assets drive conversions? Which formats resonate with your audience? These insights allow you to double down on what works and retire what doesn’t.

But don’t stop at performance metrics. Use audits to identify gaps in your content strategy. Are you missing assets for emerging channels? Are you over-investing in content that doesn’t move the needle? This level of visibility turns your content operation into a strategic lever for growth.

Finally, think about innovation. How can you use Content Hub to enable personalization at scale? How can AI-driven insights inform creative decisions? Leaders who embrace this mindset turn Content Hub from a tool into a competitive advantage.

Final Thoughts

Your current state may feel daunting, but clarity is within reach. By breaking the process into these five steps, you can transform chaos into a content strategy that drives real business outcomes. Sitecore Content Hub is powerful—but only if you implement it with intention.

Ready to start your journey? Begin with discovery. The rest will follow. If Perficient can help, reach out!

Why Observability Matters More Than Ever

Moving from traditional Sitecore deployments Sitecore AI means the infrastructure is abstracted away. That’s fantastic for agility, but it also changes how we troubleshoot. You can’t RDP onto a server and tail a file anymore; your lifeline is observability: clear signals from logs, metrics, and governed automation that tell you what’s happening across the platform and the front‑end.

What’s Different in Sitecore AI?

Logs and diagnostics are centralized. You access them via the Sitecore AI portal and the Sitecore CLI. They’re organized by environment and by role. Your front‑end application or rendering host, often a Next.js site deployed on Vercel, responsible for headless rendering and user experience has its own telemetry separate from the CMS.

So, your monitoring picture spans three surfaces: Sitecore AI logs for CMS and deployment activity, rendering host telemetry for front‑end performance, and Experience Edge signals for content delivery. Together, they describe the health of the experience, not just the servers.

Understanding the Logging Surfaces

In Sitecore AI, logs are grouped into three primary areas that each play a distinct role in diagnosing issues:

Content Management (CM) logs

• These are your first stop for diagnosing publishing failures, broken workflows, template errors, and serialization mismatches. When a publish fails, CM logs help you separate permissions or workflow problems from data or serialization issues.

Rendering Host logs

• Think front‑end behavior and performance. If personalization falls back, pages render slowly, or API responses seem sluggish, the rendering host logs surface cache misses, API latency, and rendering errors that directly impact Core Web Vitals and UX.

Deployment logs

• The “narrative” of your CI/CD run. When a build fails or a promotion doesn’t complete, deployment logs pinpoint CLI command failures, artifact mismatches, or environment configuration issues. They also provide stage-by-stage visibility (provisioning, build, deploy, post‑actions), which speeds triage and supports audits.

Access these logs quickly in the Deploy app’s environment view or programmatically via the Sitecore CLI for listing, viewing, and downloading logs as part of your pipeline artifacts.

Integration Patterns for Enterprise Monitoring

Centralizing is helpful; correlating is essential. The pragmatic pattern I recommend is:

Sitecore AI → Azure Monitor/Application Insights

• Forward CMS and deployment logs so you can correlate spikes in errors with deployments, content bursts, or traffic changes. KQL lets you slice by environment, role, and severity for root cause analysis.

Rendering Host → APM (Datadog/New Relic)

• Use front‑end analytics to track TTFB, cache hit ratio, route errors, and API dependency health. Pair this with Vercel’s own analytics for global edge performance.

Experience Edge → Webhook Monitoring

• Register webhooks so you can track publish‑to‑Edge latency and trigger alerts or redeploys when content propagation slows or fails.

SIEM Integration (today’s reality)

• For unified audit across Sitecore SaaS, stream supported Common Audit Logs (CAL) via webhooks (Personalize/CDP/Connect) and, for Sitecore AI, pull environment and deployment logs via CLI on a schedule until broader CAL coverage lands.

Metrics That Matter

In a SaaS world, traditional “server up” checks don’t describe user experience. Focus on metrics that map directly to reliability and business impact:

Deployment success & promotion health

• Failed builds or promotions block content and features. Tracking rates and mean time to recovery reveals pipeline reliability.

Publish‑to‑Edge latency

• Authors expect content to reach Experience Edge quickly. Latency here affects real‑time campaigns, previews, and editorial confidence.

Rendering host performance

• P95/P99 TTFB, cache hit ratio, and error rates impact Core Web Vitals, SEO, and conversion. They also help you spot regressions after releases.

Agent activity & governance

• With Sitecore AI’s agentic capabilities, monitoring agent runs, approvals, and failures protects compliance and prevents unintended bulk changes.

Governance Signals in Sitecore AI

Sitecore AI introduces Agentic Studio: a governed workspace to design, run, and oversee automation. Work is organized around four building blocks, Agents, Flows, Spaces, and Signals. Practically, that means you can automate complex operations while maintaining human review and auditability.

• Agents: Handle focused tasks (e.g., content migration, metadata updates).
• Flows: Orchestrate agents into multi‑step workflows with visibility across stages.
• Spaces: Provide shared context for teams to collaborate on active runs.

Signals surface trends and triggers that can start or adjust flows. Together, these give marketers and developers a safe frame to scale automation without losing control.

How Agent Flows Are Monitored

Monitoring agent flows blends product‑level visibility with enterprise analytics:

Run visibility in Agentic Studio:

• Each flow run exposes status, participants (human and agent), timestamps, and outcomes. Because flows are orchestrated in a governed workspace, you get “full visibility” into progression from brief to publish/optimization, including approvals where human review is required.

Governance signals and audit trails:

• Signals can trigger flows and also act as governance inputs (for example, trend alerts requiring approval). Capture audit trails of who initiated a run, which agents executed steps, and what content or configurations changed.

Alerting and dashboards:

• Mirror key flow events into your monitoring plane: start, paused awaiting approval, failed step, completed. Route these into Azure Monitor or your SIEM so operations sees agentic activity alongside deployments and content events.

Integration approach:

• Where Common Audit Logs (CAL) are available (Personalize/CDP/Connect), stream events via webhooks. For Sitecore AI and Agentic activity not yet covered by CAL, use scheduled CLI log exports and APIs the platform exposes to assemble a unified view. Normalize event schemas (runId, agentId, flowId, environment, severity) to enable cross‑product correlation.

The outcome: agent automation becomes observable. Teams can answer “what changed, when, by whom, and why” and tie those answers to performance and compliance dashboards.

Final Thoughts

Observability in Sitecore AI isn’t about servers; it’s about experience health and trusted automation. When you combine SaaS‑native logs, front‑end telemetry, Edge events, and agentic governance signals, you gain a single narrative across deployments, content, and automation, the narrative you need to keep teams fast, safe, and accountable.

In my previous post, Simplifying Redirect Management in Sitecore XM Cloud with Next.js and Vercel Edge Config,  I explored how Vercel Edge Config can completely transform how we manage redirects in Sitecore XM Cloud. Traditionally, redirects have lived inside Sitecore – often stored as content items or within custom redirect modules – which works well until scale, speed, and operational agility become priorities.

That’s where Vercel Edge Config steps in. By managing redirects at the edge, we can push this logic closer to users, reduce load on Sitecore instances, and make updates instantly available without redeployments. The result is faster performance, easier maintenance, and a cleaner separation of content from infrastructure logic.

In this short follow-up, I will walk you through a step-by-step migration path  from auditing your current redirects to validating, deploying, and maintaining them on Vercel Edge Config. Along the way, I will share practical tips, lessons learned, and common pitfalls to watch out for during the migration process.

Audit Existing Redirects

• Export all existing redirects from Sitecore or any external sources where they might be managed.
• Identify and remove obsolete redirects, especially those pointing to pages that no longer exist or have already been redirected elsewhere.
• Combine duplicate or overlapping entries to ensure a single source of truth for each URL.
• Validate destination URLs – make sure they’re live and resolve correctly.
• Categorize by purpose – for example, marketing redirects, content migration redirects, or structural redirects.
• If you want to store them separately, you can even use different Edge Config stores for each category. This approach can make management easier and reduce the risk of accidental overrides – I have demonstrated this setup in my previous blog.
• Keep it simple – since we’re dealing with static one-to-one redirects, focus on maintaining clean mappings that are easy to review and maintain.

Define a Flexible JSON Schema

Once you have audited and cleaned up your redirects, the next step is to decide how they will be structured and stored in Edge Config. Unlike Sitecore, where redirects might be stored as content items or within a module, Edge Config uses a key-value data model, which makes JSON the most natural format for managing redirects efficiently.

The goal here is to define a clear and reusable JSON schema that represents your redirects consistently – simple enough to maintain manually, yet flexible enough to scale across multiple environments or stores.

Here’s the schema I used in my implementation:

{
  "/old-page": { 
    "destination": "/new-page", 
    "permanent": true 
  },
  "/legacy-section": { 
    "destination": "/resources", 
    "permanent": false 
  }
}

• Each key (for example, “/old-page”) is the source path that should be redirected.
• Each value contains two properties:
  • destination – the target path where the request should redirect.
  • permanent – a boolean flag (true or false) that determines whether the redirect should use a 308 (permanent) or 307 (temporary) status code.

Automate the Export

Once you’ve finalized your redirect list and defined your JSON structure, the next step is to automate the conversion process — so you can easily transform your audited data into the format that Vercel Edge Config expects.

In my implementation, I created a C# console application that automates this step. The tool takes a simple CSV file as input and converts it into the JSON format used by Edge Config.

The CSV file includes three columns: source, destination, permanent. The application reads this CSV and generates a JSON file in the format mentioned in the above section. You can find the complete source code and instructions for this utility on my GitHub repository here: ConvertCsvToJson

• You can collect and audit redirects collaboratively in a CSV format, which non-developers can easily work with.
• Once finalized, simply run the console application to convert the CSV into JSON and upload it to Vercel Edge Config.
• If you have multiple redirect categories or stores, you can generate separate JSON files for each using different input CSVs.

Validate & Test

Before you roll out your new redirect setup, it’s important to thoroughly validate and test the data and the middleware behavior. This stage ensures your redirects work exactly as expected once they’re moved to Vercel Edge Config.

A solid validation process will help you catch issues early – like typos in paths, invalid destinations, or accidental redirect loops – while maintaining confidence in your migration.

Gradual Rollout

Once your redirects have been validated locally and in your preview environment, the next step is to roll them out safely and incrementally. The advantage of using Vercel Edge Config is that updates propagate globally within seconds – but that’s exactly why taking a controlled, phased approach is important.

After validating your redirects, roll them out gradually to avoid unexpected issues in production. Begin by deploying your Next.js middleware and Edge Config integration to a preview/test environment. This helps confirm that the application is fetching from the correct store and that updates in Edge Config appear instantly without redeployments.

Once everything looks stable, publish your redirect JSON to the production Edge Config store. Changes propagate globally within seconds, but it’s still good practice to test a few key URLs immediately. If you have logging or analytics set up (such as Analytics or custom logs), monitor request patterns for any unusual spikes, new 404s, or unexpected redirect hits.

If you’re using multiple Edge Config stores, roll them out one at a time to keep things isolated and easier to debug.
And always keep a simple rollback plan – because Edge Config maintains backup- it creates a backup each time the json is updated, you can always rollback to the previous version, with no redeploy required.

Monitor & Maintain

Once your redirects are live in Vercel Edge Config, it’s important to keep an eye on how they behave over time. Redirects aren’t a “set and forget” feature especially on sites that evolve frequently.

Use logging, analytics, or Vercel’s built-in monitoring to watch for patterns like unexpected 404s, high redirect activity, or missed routes. These signals can help you identify gaps in your redirect set or highlight URLs that need cleanup.

Review and update your redirect JSON regularly. Legacy redirects may become irrelevant as site structures change, so a quick quarterly cleanup helps keep things lean. And since your JSON is version-controlled, maintaining and rolling back changes stays simple and predictable.

If you use multiple Edge Config stores, make sure the separation stays intentional. Periodically check that each store contains only the redirects meant for it—this avoids duplication and keeps your redirect logic easy to understand.

Consistent monitoring ensures your redirect strategy remains accurate, fast, and aligned with your site’s current structure.

Migrating redirects from Sitecore to Vercel Edge Config isn’t just a technical shift – it’s an opportunity to simplify how your site handles routing, clean up years of legacy entries, and move this logic to a place thats faster, cleaner, and easier to maintain. With a thoughtful audit, a clear JSON structure, and an automated export process, the migration becomes surprisingly smooth.

As you move forward, keep an eye on the small details: avoid accidental loops, stay consistent with your paths, and use the permanent flag intentionally. A few mindful checks during rollout and a bit of monitoring afterward go a long way in keeping your redirect setup predictable and high-performing.

Ultimately, this approach not only modernizes how redirects are handled in an XM Cloud setup – it also gives you a structured, version-controlled system that’s flexible for future changes and scalable as your site evolves. Its a clean foundation you can build on confidently.

Sitecore has introduced the Content SDK for XM Cloud-now Sitecore AI to streamline the process of fetching content and rendering it on modern JavaScript front-end applications. If you’re building a website on Sitecore AI, the new Content SDK is the modern, recommended tool for your development team.

Think of it as a specialized, lightweight toolkit built for one specific job: getting content from Sitecore AI and displaying it on your modern frontend application (like a site built with Next.js).

Because it’s purpose-built for Sitecore AI, it’s fast, efficient, and doesn’t include a lot of extra baggage. It focuses purely on the essential “headless” task of fetching and rendering content.

What About the JSS SDK?
This is the original toolkit Sitecore created for headless development.

The key difference is that the JSS SDK was designed to be a one-size-fits-all solution. It had to support both the new, headless Sitecore AI and Sitecore’s older, all-in-one platform, Sitecore XP/XM.

To do this, it had to include extra code and dependencies to support older features, like the “Experience Editor”. This makes the JSS SDK “bulkier” and more complex. If you’re only using Sitecore AI, you’re carrying around a lot of extra weight you simply don’t need.

The Sitecore Content SDK is the modern, purpose-built toolkit for developers using Sitecore AI, providing seamless, out-of-the-box integration with the platform’s most powerful capabilities. This includes seamless visual editing that empowers marketers to build and edit pages in real-time, as well as built-in hooks for personalization and analytics that simplify the delivery and tracking of targeted user experiences. For developers, it provides GraphQL utilities to streamline data fetching and is deeply optimized for Next.js, enabling high-performance features like server-side rendering. Furthermore, with the recent introduction of App Router support (in beta), the SDK is evolving to give developers even more granular control over performance, SEO, bundle sizes, and security through a more modern, modular code structure.

What does the Content SDK offer?

1) App Router support (v1.2)

With version 1.2.0, Sitecore Content SDK introduces App Router support in beta. While the full fledged stable release is expected soon, developers can already start exploring its benefits and work flow with 1.2 version.
This isn’t just a minor update; it’s a huge step toward making your front-end development more flexible and highly optimized.

Why should you care? –
The App Router introduces a fantastic change to your starter application’s code structure and how routing works. Everything becomes more modular and declarative, aligning perfectly with modern architecture practices. This means defining routes and layouts is cleaner, content fetching is neatly separated from rendering, and integrating complex Next.js features like dynamic routes is easier than ever. Ultimately, this shift makes your applications much simpler to scale and maintain as they grow on Sitecore AI.

Performance: Developers can fine-tune route handling with nested layouts and more aggressive and granular caching to seriously boost overall performance, leading to faster load times.

Bundle Size: Smaller bundle size because it uses React Server Components (RSC) to render components. It help fetch and render component from server side without making the static files in bundle.

Security: It helps with security by giving improved control over access to specific routes and content.

With the starter kit applications, this is how app router routing structure looks like:

2) New configs – sitecore.config.ts & sitecore.cli.config.ts

The sitecore.config.ts file, located in the root of your application, acts as the central configuration point for Content SDK projects. It is replacement of the older temp/config file used by the JSS SDK. It contains properties that can be used throughout the application just by importing the file. It contains important properties like sitename, defaultLanguage, edge props like contextid. Starter templates include a very lightweight version containing only the mandatory parameters necessary to get started. Developers can easily extend this file as the project grows and requires more specific settings.

Key Aspects:

Environment Variable Support: This file is designed for deployment flexibility using a layered approach. Any configuration property present in this file can be sourced in three ways, listed in order of priority:

1. Explicitly defined in the configuration file itself.
2. Fallback to a corresponding environment variable (ideal for deployment pipelines).
3. Use a default value if neither of the above is provided.

This layered approach ensures flexibility and simplifies deployment across environments.

The sitecore.cli.config.ts file is dedicated to defining and configuring the commands and scripts used during the development and build phases of a Content SDK project.

Key Aspects:

CLI Command Configuration: It dictates the commands that execute as part of the build process, such as generateMetadata() and generateSites(), which are essential for generating Sitecore-related data and metadata for the front-end.

Component Map Generation: This file manages the configuration for the automatic component map generation. This process is crucial for telling Sitecore how your front-end components map to the content structure, allowing you to specify file paths to scan and define any files or folders to exclude. Explored further below.

Customization of Build Process: It allows developers to customize the Content SDK’s standard build process by adding their own custom commands or scripts to be executed during compilation.

While sitecore.config.ts handles the application’s runtime settings (like connection details to Sitecore AI), sitecore.cli.config.ts works in conjunction to handle the development-time configuration required to prepare the application for deployment.

3) Component map

In Sitecore Content SDK-based applications, every custom component must be manually registered in the .sitecore/component-map.ts file located in the app’s root. The component map is a registry that explicitly links Sitecore renderings to their corresponding frontend component implementations. The component map tells the Content SDK which frontend component to render for each component receives from Sitecore. When the rendering gets added to any page via presentation, component map tells which frontend rendering should be rendered at the place.

Key Aspects:

Unlike JSS implementations that automatically maps components, the Content SDK’s explicit component map enables better tree-shaking. Your final production bundle will only include the components you have actually registered and use, resulting in smaller, more efficient application sizes.

This is how it looks like: (Once you start creating custom component, you have to add the component name here to register.)

4) Import map

The import map is a tool used specifically by the Content SDK’s code generation feature. It manages the import paths of components that are generated or used during the build process. It acts as a guide for the code generation engine, ensuring that any new code it creates correctly references your existing components.
Where it is: It is a generated file, typically found at ./sitecore/import-map.ts, that serves as an internal manifest for the build process. You generally do not need to edit this file manually.
It simplifies the logic of code generation, guaranteeing that any newly created code correctly and consistently references your existing component modules.

The import map generation process is configurable via the sitecore.cli.config.ts file. This allows developers to customize the directories scanned for components.

5) defineMiddleware in the Sitecore Content SDK

defineMiddleware is a utility for composing a middleware chain in your Next.js app. It gives you a clean, declarative way to handle cross-cutting concerns like multi-site routing, personalization, redirects, and security all in one place. This centralization aligns perfectly with modern best practices for building scalable, maintainable functions.

The JSS SDK leverages a “middleware plugin” pattern. This system is effective for its time, allowing logic to be separated into distinct files. However, this separation often requires developers to manually manage the ordering and chaining of multiple files, which could become complex and less transparent as the application grew. The Content SDK streamlines this process by moving the composition logic into a single, highly readable utility which can customizable easily by extending Middleware

6) Debug Logging in Sitecore Content SDK

Debug logging helps you see what the SDK is doing under the hood. Super useful for troubleshooting layout/dictionary fetches, multisite routing, redirects, personalization, and more. The Content SDK uses the standard DEBUG environment variable pattern to enable logging by namespace. You can selectively turn on logging for only the areas you need to troubleshoot, such as: content-sdk:layout (for layout service details) or content-sdk:dictionary (for dictionary service details)
For all available namespaces and parameters, refer to sitecore doc – https://doc.sitecore.com/sai/en/developers/content-sdk/debug-logging-in-content-sdk-apps.html#namespaces 

7) Editing & Preview

In the context of Sitecore’s development platform, editing and preview render optimization with the Content SDK involves leveraging middleware, architecture, and framework-specific features to improve the performance of rendering content in editing and preview modes. The primary goal is to provide a fast and responsive editing experience for marketers using tools like Sitecore AI Pages and the Design Library. EditingRenderMiddleware: The Content SDK for Next.js includes optimized middleware for editing scenarios. Instead of a multi-step process involving redirects, the optimized middleware performs an internal, server-side request to return the HTML directly. This reduces overhead and speeds up rendering significantly.
This feature Works out of the box in most environments: Local container, Vercel / Netlify, SitecoreAI (defaults to localhost as configured)

For custom setups, override the internal host with: SITECORE_INTERNAL_EDITING_HOST_URL=https://host
This leverages a Integration with XM Cloud/Sitecore AI Pages for visual editing and testing of components.

8) SitecoreClient

The SitecoreClient class in the Sitecore Content SDK is a centralized data-fetching service that simplifies communication with your Sitecore content backend typically with Experience Edge or preview endpoint via GraphQL endpoints.
Instead of calling multiple services separately, SitecoreClient lets you make one organized request to fetch everything needed for a page layout, dictionary, redirects, personalization, and more.

Key Aspect:

Unified API: One client to access layout, dictionary, sitemap, robots.txt, redirects, error pages, multi-site, and personalization.
To understand all key methods supported, please refer to sitecore documentation: https://doc.sitecore.com/sai/en/developers/content-sdk/the-sitecoreclient-api.html#key-methods

9) Built-In Capabilities for Modern Web Experiences

GraphQL Utilities: Easily fetch content, layout, dictionary entries, and site info from Sitecore AI’s Edge and Preview endpoints.
Personalization & A/B/n Testing: Deploy multiple page or component variants to different audience segments (e.g., by time zone or language) with no custom code.
Multi-site Support: Seamlessly manage and serve content across multiple independent sites from a single Sitecore AI instance.
Analytics & Event Tracking: Integrated support via the Sitecore Cloud SDK for capturing user behavior and performance metrics.
Framework-Specific Features: Includes Next.js locale-based routing for internationalization, and supports both SSR and SSG for flexible rendering strategies.

10) Cursor for AI development

Starting with Content SDK version 1.1, Sitecore has provided comprehensive “Cursor rules” to facilitate AI-powered development.
The integration provides Cursor with sufficient context about the Content SDK ecosystem and Sitecore development patterns. These set of rules and context helps to accelerate the development. The cursor rules are created for contentsdk with starter application under .cursor folder. This enables the AI to better assist developers with tasks specific to building headless Sitecore components, leading to improved development consistency and speed following same patterns just by providing few commands in generic terms. Example given in below screenshot for Hero component which can act as a pattern to create another similar component by cursor.

11) Starter Templates and Example Applications

To accelerate development and reduce setup time, the Sitecore Content SDK includes a set of starter templates and example applications designed for different use cases and development styles.
The SDK provides a Next.js JavaScript starter template that enables rapid integration with Sitecore AI. This template is optimized for performance, scalability, and best practices in modern front-end development.
Starter Applications in examples

basic-nextjs -A minimal Next.js application showcasing how to fetch and render content from Sitecore AI using the Content SDK. Ideal for SSR/SSG use cases and developers looking to build scalable, production-ready apps.

basic-spa -A single-page application (SPA) example that demonstrates client-side rendering and dynamic content loading. Useful for lightweight apps or scenarios where SSR is not required.

Other demo site to showcase Sitecore AI capabilities using the Content SDK:

kit-nextjs-article-starter

kit-nextjs-location-starter

kit-nextjs-product-starter

kit-nextjs-skate-park

Final Thoughts

The Sitecore Content SDK represents a major leap forward for developers building on Sitecore AI. Unlike the older JSS SDK, which carried legacy dependencies, the Content SDK is purpose-built for modern headless architectures—lightweight, efficient, and deeply optimized for frameworks like Next.js. With features like App Router support, runtime and CLI configuration flexibility, and explicit component mapping, it empowers teams to create scalable, high-performance applications while maintaining clean, modular code structures.

In my previous blogs, I outlined key considerations for planning a Sitecore migration and shared strategies for executing it effectively. The next critical step is to understand how your business and technical requirements align with the broader Sitecore ecosystem.
Before providing careful recommendations to a customer, it’s essential to map your goals—content management, personalization, multi-site delivery, analytics, and future scalability onto Sitecore’s composable and cloud-native offerings. This ensures that migration and implementation decisions are not only feasible but optimized for long-term value.
To revisit the foundational steps and execution strategies, check out these two helpful resources:
•  Planning Sitecore Migration: Things to Consider
•  Executing a Sitecore Migration: Development, Performance, and Beyond

Sitecore is not just a CMS; it’s a comprehensive digital experience platform.
Before making recommendations to a customer, it’s crucial to clearly define what is truly needed and to have a deep understanding of how powerful Sitecore is. Its Digital Experience Platform (DXP) capabilities, including personalization, marketing automation, and analytics—combined with cloud-native SaaS delivery, enable organizations to scale efficiently, innovate rapidly, and deliver highly engaging digital experiences.
By carefully aligning customer requirements with these capabilities, you can design solutions that not only meet technical and business needs but also maximize ROI, streamline operations, and deliver long-term value.

In this blog, I’ll summarize Sitecore’s Digital Experience Platform (DXP) offerings to explore how each can be effectively utilized to meet evolving business and technical needs.

1. Sitecore XM Cloud

Sitecore Experience Manager Cloud (XM Cloud) is a cloud-native, SaaS, hybrid headless CMS designed to help businesses create and deliver personalized, multi-channel digital experiences across websites and applications. It combines the flexibility of modern headless architecture with robust authoring tools, enabling teams to strike a balance between developer agility and marketer control.

Key Capabilities

• Cloud-native: XM Cloud is built for the cloud, providing a secure, reliable, scalable, and enterprise-ready system. Its architecture ensures high availability and global reach without the complexity of traditional on-premises systems.
• SaaS Delivery: Sitecore hosts, maintains, and updates XM Cloud regularly. Organizations benefit from automatic updates, new features, and security enhancements without the need for costly installations or manual upgrades. This ensures that teams always work with the latest technologies while reducing operational overhead.
• Hybrid Headless: XM Cloud separates content and presentation, enabling developers to build custom front-end experiences using modern frameworks, while marketers utilize visual editing tools like the Page Builder to make real-time changes. This allows routine updates to be handled without developer intervention, maintaining speed and agility.
• Developer Productivity: Developers can model content with data templates, design reusable components, and assign content through data sources. Sitecore offers SDKs like the Content SDK for building personalized Next.js apps, the ASP.NET Core SDK for .NET integrations, and the Cloud SDK for extending DXP capabilities into Content SDK and JSS applications connected to XM Cloud. Starter kits are provided for setting up the code base.
• Global Content Delivery: With Experience Edge, XM Cloud provides scalable GraphQL endpoints to deliver content rapidly across geographies, ensuring consistent user experiences worldwide.
• Extensibility & AI Integration: XM Cloud integrates with apps from the Sitecore Marketplace and leverages Sitecore Stream for advanced AI-powered content generation and optimization. This accelerates content creation while maintaining brand consistency.
• Continuous Updates & Security: XM Cloud includes multiple interfaces, such as Portal, Deploy, Page Builder, Explorer, Forms, and Analytics, which are regularly updated. Deploy app to deploy to XM Cloud projects.

XM Cloud is ideal for organizations seeking a scalable, flexible, and future-proof content platform, allowing teams to focus on delivering compelling digital experiences rather than managing infrastructure.

2. Experience Platform (XP)

Sitecore Experience Platform (XP) is like an all-in-one powerhouse—it’s a complete box packed with everything you need for delivering personalized, data-driven digital experiences. While Experience Management (XM) handles content delivery, XP adds layers of personalization, marketing automation, and deep analytics, ensuring every interaction is contextually relevant and optimized for each visitor.

Key Capabilities

• Content Creation & Management: The Content Editor and Experience Editor allow marketers and content authors to create, structure, and manage website content efficiently, supporting collaboration across teams.
• Digital Marketing Tools: Built-in marketing tools enable the creation and management of campaigns, automating triggers and workflows to deliver personalized experiences across multiple channels.
• Experience Analytics: XP provides detailed insights into website performance, visitor behavior, and campaign effectiveness. This includes metrics like page performance, conversions, and user engagement patterns.
• Experience Optimization: Using analytics data, XP allows you to refine content and campaigns to achieve better results. A/B testing and multivariate testing help determine the most effective variations.
• Path Analyzer: This tool enables you to analyze how visitors navigate through your site, helping you identify bottlenecks, drop-offs, and opportunities to enhance the user experience.
  By combining these capabilities, XP bridges content and marketing intelligence, enabling teams to deliver data-driven, personalized experiences while continuously refining and improving digital engagement.

By combining these capabilities, XP bridges content and marketing intelligence, enabling teams to deliver data-driven, personalized experiences while continuously refining and improving digital engagement.

3. Sitecore Content Hub

Sitecore Content Hub unifies content planning, creation, curation, and asset management into a single platform, enabling teams to collaborate efficiently and maintain control across the entire content lifecycle and digital channels.

Key Capabilities

• Digital Asset Management (DAM): Content Hub organizes and manages images, videos, documents, and other digital assets. Assets can be tagged, annotated, searched, and shared efficiently, supporting teams in building engaging experiences without losing control over asset usage or consistency.
• Campaign & Content Planning: Teams can plan campaigns, manage editorial calendars, and assign tasks to ensure smooth collaboration between marketing, creative, and operational teams. Structured workflows enforce version control, approvals, and accountability, ensuring that content moves systematically to the end user.
• AI-Powered Enhancements: Advanced AI capabilities accelerate content operations. These intelligent features reduce manual effort, increase productivity, and help teams maintain brand consistency at scale.
• Microservice Architecture & Integration & Multi-Channel Delivery: Content Hub is built on a microservice-based architecture, allowing flexible integration with external systems, headless CMS, and cloud development pipelines. Developers can extend capabilities or connect Content Hub to other platforms without disrupting core operations. Content Hub ensures that teams can deliver consistent, high-quality experiences across websites, social media, commerce, and other digital channels.

Sitecore Content Hub empowers organizations to manage content as a strategic asset, streamlining operations, enabling global collaboration, and providing the technical flexibility developers need to build integrated, scalable solutions.

strong>4. Sitecore Customer Data Platform (CDP)

Sitecore Customer Data Platform (CDP) enables organizations to collect customer data across all digital channels, providing a single, unified view of every user. By centralizing behavioral and transactional data, CDP allows businesses to deliver personalized experiences and data-driven marketing at scale.

Key Capabilities

• Real-Time Data Collection: The Stream API captures live behavioral and transactional data from your applications and sends it to Sitecore CDP in real time. This ensures that customer profiles are always up-to-date and that personalization can be applied dynamically as users interact with your digital properties.
• Batch Data Upload: For larger datasets, including guest data or offline orders, the Batch API efficiently uploads bulk information into CDP, keeping your customer data repository comprehensive and synchronized.
• CRUD Operations: Sitecore CDP offers REST APIs for retrieving, creating, updating, and deleting customer data. This enables developers to integrate external systems, enrich profiles, or synchronize data between multiple platforms with ease.
• Data Lake Export: With the Data Lake Export Service, all organizational data can be accessed from Amazon S3, allowing it to be downloaded locally or transferred to another S3 bucket for analysis, reporting, or integration with external systems.
• SDK Integrations (Cloud SDK & Engage SDK): Developers can leverage Sitecore’s Cloud SDK and Engage SDK to streamline data collection, manage user information, and integrate CDP capabilities directly into applications. These SDKs simplify the process of connecting applications to XM Cloud and other services to CDP, enabling real-time engagement and seamless data synchronization.

Sitecore CDP captures behavioral and transactional interactions across channels, creating a unified, real-time profile for each customer. These profiles can be used for advanced segmentation, targeting, and personalization, which in turn informs marketing strategies and customer engagement initiatives.
By integrating CDP with other components of the Sitecore ecosystem—such as DXP, XM Cloud, and Content Hub —organizations can efficiently orchestrate personalized, data-driven experiences across websites, apps, and other digital touchpoints.

5. Sitecore Personalize

Sitecore Personalize enables organizations to deliver seamless, consistent, and highly relevant experiences across websites, mobile apps, and other digital channels. By leveraging real-time customer data, predictive insights, and AI-driven decisioning, it ensures that the right content, offers, and messages get delivered to the target customer/audience.

Key Capabilities

• Personalized Experiences: Deliver tailored content and offers based on real-time user behavior, predictive analytics, and unified customer profiles. Personalization can be applied across web interactions, server-side experiences, and triggered channels, such as email or SMS, ensuring every interaction is timely and relevant.
• Testing and Optimization: Conduct A/B/n tests and evaluate which variations perform best based on actual customer behavior. This enables continuous optimization of content, campaigns, and personalization strategies.
• Performance Analytics: Track user interactions and measure campaign outcomes to gain actionable insights. Analytics support data-driven refinement of personalization, ensuring experiences remain effective and relevant.
• Experiences and Experiments: Helps to create a tailored experience for each user depending on interaction and any other relevant user data.
• AI-Driven Assistance: The built-in Code Assistant can turn natural language prompts into JavaScript, allowing developers to quickly create custom conditions, session traits, and programmable personalization scenarios without writing code from scratch.

By combining real-time data from CDP, content from XM Cloud and Content Hub, and AI-driven decisioning, Sitecore Personalize allows organizations to orchestrate truly unified, intelligent, and adaptive customer experiences. This empowers marketers and developers to respond dynamically to signals, test strategies, and deliver interactions that drive engagement and value, along with a unique experience for users.

6. Sitecore Send

Sitecore Send is a cloud-based email marketing platform that enables organizations to create, manage, and optimize email campaigns. By combining automation, advanced analytics, and AI-driven capabilities, marketing teams can design, execute, and optimize email campaigns efficiently without relying heavily on IT support.

Key Capabilities

• Campaign Creation & Management: Sitecore Send offers a no-code campaign editor that enables users to design campaigns through drag-and-drop and pre-built templates. Marketers can create campaigns quickly, trigger messages automatically, and also perform batch sends.
• A/B Testing & Optimization: Campaigns can be A/B tested to determine which version resonates best with the target audience, helping improve open rates, click-through rates, and overall engagement.
• AI-Powered Insights: Built-in AI capabilities help optimize send times, segment audiences, and predict engagement trends, ensuring messages are timely, relevant, and impactful.
• API Integration: The Sitecore Send API enables developers to integrate email marketing functionality directly into applications. It supports tasks such as:
  • Creating and managing email lists
  • Sending campaigns programmatically
  • Retrieving real-time analytics
  • Automating repetitive tasks
  • This API-driven approach allows teams to streamline operations, accelerate campaign delivery, and leverage programmatic control over their marketing initiatives.

Sitecore Send integrates seamlessly with the broader Sitecore ecosystem, using real-time data from CDP and leveraging content from XM Cloud or Content Hub. Combined with personalization capabilities, it ensures that email communications are targeted, dynamic, and aligned with overall customer experience strategies.
By centralizing email marketing and providing programmatic access, Sitecore Send empowers organizations to deliver scalable, data-driven campaigns while maintaining full control over creative execution and performance tracking.

7. Sitecore Search

Sitecore Search is a headless search and discovery platform that delivers fast, relevant, and personalized results across content and products. It enables organizations to create predictive, AI-powered, intent-driven experiences that drive engagement, conversions, and deeper customer insights.

Key Capabilities

• Personalized Search & Recommendations: Uses visitor interaction tracking and AI/ML algorithms to deliver tailored search results and product/content recommendations in real time.
• Headless Architecture: Decouples search and discovery from presentation, enabling seamless integration across websites, apps, and other digital channels.
• Analytics & Optimization: Provides rich insights into visitor behavior, search performance, and business impact, allowing continuous improvement of search relevance and engagement.
• AI & Machine Learning Core: Sophisticated algorithms analyze large datasets—including visitor location, preferences, interactions, and purchase history to deliver predictive, personalized experiences.

With Sitecore Search, organizations can provide highly relevant, omnichannel experiences powered by AI-driven insights and advanced analytics.

8. Sitecore Discover

Sitecore Discover is an AI-driven product search similar to sitecore search, but this is more product and commerce-centric. It enables merchandisers and marketers to deliver personalized shopping experiences across websites and apps. By tracking user interactions, it generates targeted recommendations using AI recipes, such as similar products and items bought together, which helps increase engagement and conversions. Merchandisers can configure pages and widgets via the Customer Engagement Console (CEC) to create tailored, data-driven experiences without developer intervention.

Search vs. Discover

• Sitecore Search: Broad content/product discovery, developer-driven, AI/ML-powered relevance, ideal for general omnichannel search. Optimized for content and product discovery.
• Sitecore Discover: Commerce-focused product recommendations, merchandiser-controlled, AI-driven personalization for buying experiences. Optimized for commerce personalization and merchandising.

9. Sitecore Connect

Sitecore Connect is an integration tool that enables seamless connections between Sitecore products and other applications in your ecosystem, creating end-to-end, connected experiences for websites and users.

Key Capabilities

• Architecture: Built around recipes and connectors, Sitecore Connect offers a flexible and scalable framework for integrations.
• Recipes: Automated workflows that define triggers (events occurring in applications) and actions (tasks executed when specific events occur), enabling process automation across systems.
• Connectors: Manage connectivity and interactivity between applications, enabling seamless data exchange and coordinated workflows without requiring complex custom coding.

With Sitecore Connect, organizations can orchestrate cross-system processes, synchronize data, and deliver seamless experiences across digital touchpoints, all while reducing manual effort and integration complexity.

10. OrderCloud

OrderCloud is a cloud-based, API-first, headless commerce and marketplace platform designed for B2B, B2C, and B2X scenarios. It provides a flexible, scalable, and fully customizable eCommerce architecture that supports complex business models and distributed operations.

Key Capabilities

• Headless & API-First: Acts as the backbone of commerce operations, allowing businesses to build and connect multiple experiences such as buyer storefronts, supplier portals, or admin dashboards—on top of a single commerce platform.
• Customizable Commerce Solutions: Supports large and complex workflows beyond traditional shopping carts, enabling tailored solutions for distributed organizations.
• Marketplace & Supply Chain Support: Facilitates selling across extended networks, including suppliers, franchises, and partners, while centralizing order management and commerce operations.

OrderCloud empowers organizations to scale commerce operations, extend digital selling capabilities, and create fully customized eCommerce experiences, all while leveraging a modern, API-first headless architecture.

Final Thoughts

Sitecore’s composable DXP products and its suite of SDKs empower organizations to build scalable, personalized, and future-ready digital experiences. By understanding how each component fits into your architecture and aligns with your  business goals, you can make informed decisions that drive long-term value. Whether you’re modernizing legacy systems or starting fresh in the cloud, aligning your strategy with Sitecore’s capabilities ensures a smoother migration and a more impactful digital transformation.

In my previous blog, Unlocking Advanced Personalization in Sitecore XM Cloud with Sitecore Personalize, I explored how the integration between Sitecore XM Cloud and Sitecore Personalize unlocks advanced personalization capabilities – enabling cross-channel decisioning, custom audiences, and real-time variants. In that post I explained the architecture, the run-time flow, and why the default embedded personalization in XM Cloud may not suffice for developers looking to implement deep, business-specific personalization logic.

In this follow-up, we will dig deeper and focus on how to extend personalization in XM Cloud by creating custom conditions in Sitecore Personalize. We will walk through the step-by-step process: defining a use case, writing condition logic, testing and publishing it, and then applying it to a real experience. By the end of this blog, you will be equipped to build your own developer-written conditions that marketers can reuse in their audience builder – taking personalization beyond the out-of-box and into true business-driven differentiation.

What Are Conditions in Sitecore Personalize and Why Custom Conditions Matter

• Out-of-the-box conditions- prebuilt by Sitecore (geolocation, device type, visit behavior, etc.).
• Custom conditions – where you define your own logic, often using JavaScript (or assisted by AI if you enable the Code Assistant), to handle business/custom data and decisioning.

How Conditions Work – The Mental Model

When you write a custom condition in Personalize:

1. You define input parameters (if any) – these become configurable by authors when applying the condition.
2. You write logic (in JavaScript) that reads visitor/session/guest data (or external data if you fetch it), evaluates your business rule, and returns a boolean (true/false) or a structured object depending on the expectation.
3. You define a friendly output – a human-readable sentence (with placeholders for input parameters) that authors see when selecting the condition for an experience or experiment.
4. Once you save and publish the condition, it’s available alongside other conditions (out-of-the-box or custom) in the conditions library, and can be applied by marketers without coding.

Because Personalize and SitecoreAI are connected already, all the custom conditions created here are automatically available in the Page Builder – so authors can use it in experiences without needing developer deployments.

How to Create a Custom Condition – Step by Step

Here’s the standard workflow:

1. Navigate to Developer center → Conditions in Sitecore Personalize.

2. Click Create, or duplicate an existing condition and modify it as needed. The out-of-the-box (OOTB) conditions are very useful – you can review their JavaScript code for reference when building your own custom conditions.

3. Provide a name for your condition.

4. Open the code editor (click Edit). The code must be written in JavaScript.

5.If needed, define input parameters (for example: a string, number, or list) – these will show up later when configuring the condition in an experience.

6.Write the logic to compute condition result. Use local variables, avoid global object modifications, namespace shared logic if reusing across conditions  to avoid conflicts.

7.Switch to the Configuration tab to define the condition output text – how this condition will be displayed in the UI, with placeholders for your defined input parameters using double square-brackets ([[parameterName]]). Missing parameters or incorrect syntax will show errors.

8.Once you’ve defined the code and output, test the condition using sample guest data. You can either retrieve a guest ID from the browser or use a known visitor ID.
To find the guest reference ID:

• Open the Sitecore AI-integrated webpage in your browser.
• Inspect the page and navigate to Application → Cookies.
• In your site’s cookies, look for a cookie named sc_<id>_personalize.
  This value is your guest reference ID and can be used to verify that the logic works as expected.

Added a Guest Reference

Add Conditional Parameters

Test Response

9.If test passes, Publish the condition so it’s available for use in Experiences.

Thats it – your custom condition is now part of the Conditions Library and ready to be used by content or marketing authors.

If your organization has enabled the Code Assistant via Sitecore Stream, you can even bypass manual JS –  just describe what you need in plain English, and the assistant generates code for you. But always review/test it.

Wrapping Up

Custom conditions are one of those features that quietly but significantly elevate the personalization strategy for any XM Cloud + Personalize implementation, they bridge the gap between what the platform provides and what your business actually needs. They let you capture the nuances of your business rules and make them reusable, testable, and accessible to content authors without additional development cycles.

Think of them as building blocks: once you define the logic correctly, authors can mix and match them to create highly targeted experiences – all without touching code. And thats exactly where the strength of the platform lies.

This wraps up the last part of my personalization series, but I hope it’s also the beginning of you exploring personalization in a more thoughtful and structured way. If you have been relying only on out-of-the-box rules, try creating your first custom condition – the clarity and control it brings is genuinely worth it.

As organizations continue their journey toward composable and headless architectures, the way we manage even simple things like redirects evolves too. Redirects are essential for SEO and user experience, but managing them within a CMS often introduces unnecessary complexity. In this blog, I will share how we streamlined redirect management for a Sitecore XM Cloud + Next.js implementation using Vercel Edge Config  – a modern, edge-based approach that improves performance, scalability, and ease of maintenance.

Why Move Redirects Out of Sitecore?

Traditionally, redirects were managed within Sitecore through redirect items stored in the Content Tree. While functional, this approach introduced challenges such as scattered items, and added routing overhead. With Sitecore XM Cloud and Next.js, we now have the opportunity to offload this logic to the frontend layer – closer to where routing happens. By using Vercel Edge Config, redirects are processed at the edge, improving site performance and allowing instant updates without redeployments.

By leveraging Vercel Edge Config and Next.js Middleware, redirects are evaluated before the request reaches the application’s routing or backend systems. This approach ensures:

1. Redirects are processed before routing to Sitecore.
2. Updates are instant and do not require deployments.
3. Configuration is centralized and easily maintainable.

The New Approach: Redirects at the Edge

In the new setup:

1. Redirect rules are stored in Vercel Edge Config in JSON format.
2. Next.js middleware runs at the edge layer before routing.
3. Middleware fetches redirect rules and checks for matches.
4. Matching requests are redirected immediately – bypassing Sitecore.
5. Non-matching requests continue to the standard rendering process.

Technical Details and Implementation

Edge Config Setup in Vercel

Redirect rules are stored in Vercel Edge Config, a globally distributed key-value store that allows real-time configuration access at the edge. In Vercel, each project can be linked to one or more Edge Config stores.

You can create edge config stores at project level as well as at account level. In this document, we will be creating the store at account level and this edge config store will be shared across all the projects within the account.

Steps:

1.  Open the Vercel Dashboard.
2. Go to Storage -> Edge Config.
3. Create a new store (for example: redirects-store).
   
4. Add a key named redirects with redirect data in JSON format.
   Example JSON structure:

   {
     "redirects": {
       "/old-page": {
         "destination": "/new-page",
         "permanent": true
       },
       "/old-page/item-1": {
         "destination": "/new-page./item-1",
         "permanent": false
       }
     }
   }

5. To connect your store to a project, navigate to Projects tab and click on Connect Project button.

6. Select the project from the dropdown and click Connect.
   

7. Vercel automatically generates a unique Edge Config Connection String for your project which is stored as an environment variable in your project. This connection string securely links your Next.js app to the Edge Config store. You can choose to edit the environment variable name and token name from the Advanced Options while connecting a project.

8. Please note that EDGE_CONFIG environment that is added by default (if you do not update the name of the env. variable as mentioned in step #7). This environment variable is automatically available inside the Edge Runtime and used by the Edge Config SDK.

Implementing Redirect Logic in Next.js Middleware

1. Install the Vercel Edge Config SDK to fetch data from the Edge Config store:

   npm install @vercel/edge-config

   The SDK provides low-latency, read-only access to configuration data replicated across Vercel’s global edge network. Import the SDK and use it within your middleware to fetch redirect data efficiently.

2. Middleware Configuration: All redirect logic is handled in the middleware.ts file located at the root of the Next.js application. This setup ensures that every incoming request is intercepted, evaluated against the defined redirect rules, and redirected if necessary – before the request proceeds through the rest of the lifecycle.Code when using single store and the default env. variable EDGE_CONFIG

   import { NextResponse } from 'next/server';
   import type { NextFetchEvent, NextRequest } from 'next/server';
   import { get } from '@vercel/edge-config';
   
   export async function middleware(req: NextRequest, ev: NextFetchEvent) {
     try {
       const pathname = req.nextUrl.pathname;
   
       // Normalize the pathname to ensure consistent matching
       const normalizedPathname = pathname.replace(/\/$/, '').toLowerCase();
   
       // Fetch redirects from Vercel Edge Config using the EDGE_CONFIG connection
       const redirects = await get('redirects');
   
       const redirectEntries = typeof redirects === 'string' ? JSON.parse(redirects) : redirects;
   
       // Match redirect rule
       const redirect = redirectEntries[normalizedPathname];
   
       if (redirect) {
         const statusCode = redirect.permanent ? 308 : 307;
         let destinationUrl = redirect.destination;
         //avoid cyclic redirects
         if (normalizedPathname !== destinationUrl) {
           // Handle relative URLs
           if (!/^https?:\/\//.test(redirect.destination)) {
             const baseUrl = `${req.nextUrl.protocol}//${req.nextUrl.host}`;
             destinationUrl = new URL(redirect.destination, baseUrl).toString();
           }
           return NextResponse.redirect(destinationUrl, statusCode);
         }
       }
   
       return middleware(req, ev);
     } catch (error) {
       console.error('Error in middleware:', error);
       return middleware(req, ev);
     }
   }
   
   export const config = {
     /*
      * Match all paths except for:
      * 1. /api routes
      * 2. /_next (Next.js internals)
      * 3. /sitecore/api (Sitecore API routes)
      * 4. /- (Sitecore media)
      * 5. /healthz (Health check)
      * 6. all root files inside /public
      */
     matcher: ['/', '/((?!api/|_next/|healthz|sitecore/api/|-/|favicon.ico|sc_logo.svg|throw/).*)'],
   };

   Code when using multiple stores and custom environment variables. In this example, there are two Edge Config stores, each linked to its own environment variable: EDGE_CONFIG_CONSTANT_REDIRECTS and EDGE_CONFIG_AUTHORABLE_REDIRECTS. The code first checks for a redirect in the first store, and if not found, it checks the second. An Edge Config Client is required to retrieve values from each store.

   import { NextRequest, NextFetchEvent } from 'next/server';
   import { NextResponse } from 'next/server';
   import middleware from 'lib/middleware';
   import { createClient } from '@vercel/edge-config';
   
   export default async function (req: NextRequest, ev: NextFetchEvent) {
     try {
       const pathname = req.nextUrl.pathname;
   
       // Normalize the pathname to ensure consistent matching
       const normalizedPathname = pathname.replace(/\/$/, '').toLowerCase();
   
       // Fetch Redirects from Store1
       const store1RedirectsClient = createClient(process.env.EDGE_CONFIG_CONSTANT_REDIRECTS);
       const store1Redirects = await store1RedirectsClient .get('redirects');
   
       //Fetch Redirects from Store2
       const store2RedirectsClient = createClient(process.env.EDGE_CONFIG_AUTHORABLE_REDIRECTS);
       const store2Redirects = await store2RedirectsClient.get('redirects');
   
       let redirect;
   
       if (store1Redirects) {
         const redirectEntries =
           typeof store1Redirects === 'string'
             ? JSON.parse(store1Redirects)
             : store1Redirects;
   
         redirect = redirectEntries[normalizedPathname];
       }
   
       // If redirect is not present in permanent redirects, lookup in the authorable redirects store.
       if (!redirect) {
         if (store2Redirects) {
           const store2RedirectEntries =
             typeof store2Redirects === 'string'
               ? JSON.parse(store2Redirects)
               : store2Redirects;
   
           redirect = store2RedirectEntries[normalizedPathname];
         }
       }
   
       if (redirect) {
         const statusCode = redirect.permanent ? 308 : 307;
         let destinationUrl = redirect.destination;
   
         if (normalizedPathname !== destinationUrl) {
           // Handle relative URLs
           if (!/^https?:\/\//.test(redirect.destination)) {
             const baseUrl = `${req.nextUrl.protocol}//${req.nextUrl.host}`;
             destinationUrl = new URL(redirect.destination, baseUrl).toString();
           }
           return NextResponse.redirect(destinationUrl, statusCode);
         }
       }
   
       return middleware(req, ev);
     } catch (error) {
       console.error('Error in middleware:', error);
       return middleware(req, ev);
     }
   }
   
   export const config = {
     /*
      * Match all paths except for:
      * 1. /api routes
      * 2. /_next (Next.js internals)
      * 3. /sitecore/api (Sitecore API routes)
      * 4. /- (Sitecore media)
      * 5. /healthz (Health check)
      * 6. all root files inside /public
      */
     matcher: [
       '/',
       '/((?!api/|_next/|healthz|sitecore/api/|-/|favicon.ico|sc_logo.svg|throw/).*)',
     ],
   };

Summary

With this setup:

• The Edge Config store is linked to your Vercel project via environment variables.
• Redirect data is fetched instantly at the Edge Runtime through the SDK.
• Each project can maintain its own independent redirect configuration.
• All updates reflect immediately – no redeployment required.

Points to Remember:

• Avoid overlapping or cyclic redirects.
• Keep all redirects lowercase and consistent.
• The Edge Config connection string acts as a secure token – it should never be exposed in the client or source control.
• Always validate JSON structure before saving in Edge Config.
• A backup is created on every write, maintaining a version history that can be accessed from the Backups tab of the Edge Config store.
• Sitecore-managed redirects remain supported when necessary for business or content-driven use cases.

Managing redirects at the edge has made our Sitecore XM Cloud implementations cleaner, faster, and easier to maintain. By shifting this responsibility to Next.js Middleware and Vercel Edge Config, we have created a more composable and future-ready approach that aligns perfectly with modern digital architectures.

At Perficient, we continue to adopt and share solutions that simplify development while improving site performance and scalability. If you are working on XM Cloud or planning a headless migration, this edge-based redirect approach is a great way to start modernizing your stack.

In previous blog, the strategic and architectural considerations that set the foundation for a successful Sitecore migration is explored. Once the groundwork is ready, it’s time to move from planning to execution, where the real complexity begins. The development phase of a Sitecore migration demands precision, speed, and scalability. From choosing the right development environment and branching strategy to optimizing templates, caching, and performance, every decision directly impacts the stability and maintainability of your new platform.

This blog dives into the practical side of migration, covering setup best practices, developer tooling (IDE and CI/CD), coding standards, content model alignment, and performance tuning techniques to help ensure that your transition to Sitecore’s modern architecture is both seamless and future-ready.Title (suggested): Executing a Successful Sitecore Migration: Development, Performance, and Beyond

1. Component and Code Standards Over Blind Reuse

• In any Sitecore migration, one of the biggest mistakes teams make is lifting and shifting old components into the new environment. While this may feel faster in the short term, it creates long-term problems.
• Missed product offerings: Old components were often built around constraints of an earlier Sitecore version. Reusing them as-is means you can’t take advantage of new product features like improved personalization, headless capabilities, SaaS integrations, and modern analytics.
• Outdated standards: Legacy code usually does not meet current coding, security, and performance standards. This can introduce vulnerabilities and inefficiencies into your new platform.
  Accessibility gaps: Many older components don’t align with WCAG and ADA accessibility standards — missing ARIA roles, semantic HTML, or proper alt text. Reusing them will carry accessibility debt into your fresh build.
• Maintainability issues: Old code often has tight coupling, minimal test coverage, and obsolete dependencies. Keeping it will slow down future upgrades and maintenance.

Best practice: Treat the migration as an opportunity to raise your standards. Audit old components for patterns and ideas, but don’t copy-paste them. Rebuild them using modern frameworks, Sitecore best practices, security guidelines, and accessibility compliance. This ensures the new solution is future-proof and aligned with the latest Sitecore roadmap.

2. Template Creation and Best Practices

• Templates define the foundation of your content structure, so designing them carefully is critical.
• Analyze before creating: Study existing data models, pages, and business requirements before building templates.
• Use base templates: Group common fields (e.g., Meta, SEO, audit info) into base templates and reuse them across multiple content types.
• Leverage branch templates: Standardize complex structures (like a landing page with modules) by creating branch templates for consistency and speed.
• Follow naming and hierarchy conventions: Clear naming and logical organization make maintenance much easier.

3. Development Practices and Tools

A clean, standards-driven development process ensures the migration is efficient, maintainable, and future-proof. It’s not just about using the right IDEs but also about building code that is consistent, compliant, and friendly for content authors.

• IDEs & Tools
  • Use Visual Studio or VS Code with Sitecore- and frontend-specific extensions for productivity.
  • Set up linting, code analysis, and formatting tools (ESLint, Prettier in case of JSS code, StyleCop) to enforce consistency.
  • Use AI assistance (GitHub Copilot, Codeium, etc.) to speed up development, but always review outputs for compliance and quality. There are many different AI tools available in market that can even change the design/prototypes into specified code language.

• Coding Standards & Governance
  • Follow SOLID principles and keep components modular and reusable.
  • Ensure secure coding standards: sanitize inputs, validate data, avoid secrets in code.
  • Write accessible code: semantic HTML, proper ARIA roles, alt text, and keyboard navigation.
  • Document best practices and enforce them with pull request reviews and automated checks.

• Package & Dependency Management
  • Select npm/.NET packages carefully: prefer well-maintained, community-backed, and security-reviewed ones.
  • Avoid large, unnecessary dependencies that bloat the project.
  • Run dependency scanning tools to catch vulnerabilities.
  •  Keep lockfiles for environment consistency.

• Rendering Variants & Parameters
  • Leverage rendering variants (SXA/headless) to give flexibility without requiring code changes.
  • Add parameters so content authors can adjust layouts, backgrounds, or alignment safely.
  • Always provide sensible defaults to protect design consistency.

• Content Author Experience

Build with the content author in mind:

• • Use clear, meaningful field names and help text.
  • Avoid unnecessary complexity: fewer, well-designed fields are better.
  • Create modular components that authors can configure and reuse.
  • Validate with content author UAT to ensure the system is intuitive for day-to-day content updates.

Strong development practices not only speed up migration but also set the stage for easier maintenance, happier authors, and a longer-lasting Sitecore solution.

4. Data Migration & Validation

Migrating data is not just about “moving items.” It’s about translating old content into a new structure that aligns with modern Sitecore best practices.

• Migration tools
  Sitecore does provides migration tools to shift data like XM to XM Cloud. Leverage these tools for data that needs to be copied.
• PowerShell for Migration
  • Use Sitecore PowerShell Extensions (SPE) to script the migration of data from the old system that does not need to be as is but in different places and field from old system.
  • Automate bulk operations like item creation, field population, media linking, and handling of multiple language versions.
  • PowerShell scripts can be run iteratively, making them ideal as content continues to change during development.
  • Always include logging and reporting so migrated items can be tracked, validated, and corrected if needed.

• Migration Best Practices

• • Field Mapping First: Analyze old templates and decide what maps directly, what needs transformation, and what should be deprecated.
  • Iterative Migration: Run migration scripts in stages, validate results, and refine before final cutover.
  • Content Cleanup: Remove outdated, duplicate, or unused content instead of carrying it forward.
  • SEO Awareness: Ensure titles, descriptions, alt text, and canonical fields are migrated correctly.
  • Audit & Validation:
    • Use PowerShell reports to check item counts, empty fields, or broken links.
    • Crawl both old and new sites with tools like Screaming Frog to compare URLs, metadata, and page structures.

5. SEO Data Handling

SEO is one of the most critical success factors in any migration — if it’s missed, rankings and traffic can drop overnight.

• Metadata: Preserve titles, descriptions, alt text, and Open Graph tags. Missing these leads to immediate SEO losses.
• Redirects: Map old URLs with 301 redirects (avoid chains). Broken redirects = lost link equity.
• Structured Data: Add/update schema (FAQ, Product, Article, VideoObject). This improves visibility in SERPs and AI-generated results.
• Core Web Vitals: Ensure the new site is fast, stable, and mobile-first. Poor performance = lower rankings.
• Emerging SEO: Optimize for AI/Answer Engine results, focus on E-E-A-T (author, trust, freshness), and create natural Q&A content for voice/conversational search.
• Validation: Crawl the site before and after migration with tools like Screaming Frog or Siteimprove to confirm nothing is missed.

Strong SEO handling ensures the new Sitecore build doesn’t just look modern — it retains rankings, grows traffic, and is ready for AI-powered search.

6. Serialization & Item Deployment

Serialization is at the heart of a smooth migration and ongoing Sitecore development. Without the right approach, environments drift, unexpected items get deployed, or critical templates are missed.

• Best Practices
  • Choose the Right Tool: Sitecore Content Serialization (SCS), Unicorn, or TDS — select based on your project needs.
  • Scope Carefully: Serialize only what is required (templates, renderings, branches, base content). Avoid unnecessary content items.
  • Organize by Modules: Structure serialization so items are grouped logically (feature, foundation, project layers). This keeps deployments clean and modular.
  • Version Control: Store serialization files in source control (Git/Azure devops) to track changes and allow safe rollbacks.
  • Environment Consistency: Automate deployment pipelines so serialized items are promoted consistently from dev → QA → UAT → Prod.
  • Validation: Always test deployments in lower environments first to ensure no accidental overwrites or missing dependencies.

Properly managed serialization ensures clean deployments, consistent environments, and fewer surprises during migration and beyond.

7. Forms & Submissions

In Sitecore XM Cloud, forms require careful planning to ensure smooth data capture and migration.

•  XM Cloud Forms (Webhook-based): Submit form data via webhooks to CRM, backend, or marketing platforms. Configure payloads properly and ensure validation, spam protection, and compliance.
• Third-Party Forms: HubSpot, Marketo, Salesforce, etc., can be integrated via APIs for advanced workflows, analytics, and CRM connectivity.
• Create New Forms: Rebuild forms with modern UX, accessibility, and responsive design.
• Migrate Old Submission Data: Extract and import previous form submissions into the new system or CRM, keeping field mapping and timestamps intact.
• Best Practices: Track submissions in analytics, test end-to-end, and make forms configurable for content authors.

This approach ensures new forms work seamlessly while historical data is preserved.

8. Personalization & Experimentation

Migrating personalization and experimentation requires careful planning to preserve engagement and insights.

• Export & Rebuild: Export existing rules, personas, and goals. Review them thoroughly and recreate only what aligns with current business requirements.
• A/B Testing: Identify active experiments, migrate if relevant, and rerun them in the new environment to validate performance.
• Sitecore Personalize Implementation:
  • Plan data flow into the CDP and configure event tracking.
  • Implement personalization via Sitecore Personalize Cloud or Engage SDK for xm cloud implementation, depending on requirements.

Best Practices:

• Ensure content authors can manage personalization rules and experiments without developer intervention.
• Test personalized experiences end-to-end and monitor KPIs post-migration.

A structured approach to personalization ensures targeted experiences, actionable insights, and a smooth transition to the new Sitecore environment.

9. Accessibility

Ensuring accessibility is essential for compliance, usability, and SEO.

• Follow WCAG standards: proper color contrast, semantic HTML, ARIA roles, and keyboard navigation.
• Validate content with accessibility tools and manual checks before migration cutover.
• Accessible components improve user experience for all audiences and reduce legal risk.

10. Performance, Caching & Lazy Loading

Optimizing performance is critical during a migration to ensure fast page loads, better user experience, and improved SEO.

• Caching Strategies:
  • Use Sitecore output caching and data caching for frequently accessed components.
  • Implement CDN caching for media assets to reduce server load and improve global performance.
  • Apply cache invalidation rules carefully to avoid stale content.
• Lazy Loading:
  • Load images, videos, and heavy components only when they enter the viewport.
  • Improves perceived page speed and reduces initial payload.
• Performance Best Practices:
  • Optimize images and media (WebP/AVIF).
  • Minimize JavaScript and CSS bundle size, and use tree-shaking where possible.
  • Monitor Core Web Vitals (LCP, CLS, FID) post-migration.
  • Test performance across devices and regions before go-live.
  • Content Author Consideration:
  • Ensure caching and lazy loading do not break dynamic components or personalization.
  • Provide guidance to authors on content that might impact performance (e.g., large images or embeds).

Proper caching and lazy loading ensure a fast, responsive, and scalable Sitecore experience, preserving SEO and user satisfaction after migration.

11. CI/CD, Monitoring & Automated Testing

A well-defined deployment and monitoring strategy ensures reliability, faster releases, and smooth migrations.

• CI/CD Pipelines:
  • Set up automated builds and deployments according to your hosting platform: Azure, Vercel, Netlify, or on-premise.
  • Ensure deployments promote items consistently across Dev → QA → UAT → Prod.
  • Include code linting, static analysis, and unit/integration tests in the pipeline.
• Monitoring & Alerts:
  • Track website uptime, server health, and performance metrics.
  • Configure timely alerts for downtime or abnormal behavior to prevent business impact.
• Automated Testing:
  • Implement end-to-end, regression, and smoke tests for different environments.
  • Include automated validation for content, forms, personalization, and integrations.
  • Integrate testing into CI/CD pipelines to catch issues early.
• Best Practices:
  • Ensure environment consistency to prevent drift.
  • Use logs and dashboards for real-time monitoring.
  • Align testing and deployment strategy with business-critical flows.

A robust CI/CD, monitoring, and automated testing strategy ensures reliable deployments, reduced downtime, and faster feedback cycles across all environments.

12. Governance, Licensing & Cutover

A successful migration is not just technical — it requires planning, training, and governance to ensure smooth adoption and compliance.

• License Validation: Compare the current Sitecore license with what the new setup requires. Ensure coverage for all modules, environments. Validate and provide accurate rights to users and roles.
• Content Author & Marketer Readiness:
  • Train teams on the new workflows, tools, and interface.
  • Provide documentation, demos, and sandbox environments to accelerate adoption.
• Backup & Disaster Recovery:
  • Plan regular backups and ensure recovery procedures are tested.
  • Define RTO (Recovery Time Objective) and RPO (Recovery Point Objective) for critical data.
• Workflow, Roles & Permissions:
  • Recreate workflows, roles, and permissions in the new environment.
  • Implement custom workflows if required.
  • Governance gaps can lead to compliance and security risks — audit thoroughly.
• Cutover & Post-Go-Live Support:
  • Plan the migration cutover carefully to minimize downtime.
  • Prepare a support plan for immediate issue resolution after go-live.
  • Monitor KPIs, SEO, forms, personalization, and integrations to ensure smooth operation.

Proper governance, training, and cutover planning ensures the new Sitecore environment is compliant, adopted by users, and fully operational from day one.

13. Training & Documentation

Proper training ensures smooth adoption and reduces post-migration support issues.

• Content Authors & Marketers: Train on new workflows, forms, personalization, and content editing.
• Developers & IT Teams: Provide guidance on deployment processes, CI/CD, and monitoring.
• Documentation: Maintain runbooks, SOPs, and troubleshooting guides for ongoing operations.
• Encourage hands-on sessions and sandbox practice to accelerate adoption.

Summary:

Sitecore migrations are complex, and success often depends on the small decisions made throughout development, performance tuning, SEO handling, and governance. This blog brings together practical approaches and lessons learned from real-world implementations — aiming to help teams build scalable, accessible, and future-ready Sitecore solutions.

While every project is different, the hope is that these shared practices offer a useful starting point for others navigating similar journeys. The Sitecore ecosystem continues to evolve, and so do the ways we build within it.

We’re thrilled to announce that Perficient is a proud sponsor of Sitecore Symposium 2025, the premier event for digital experience leaders, marketers, and technologists. This year’s event takes place November 3-5 at the Walt Disney World Dolphin Resort in Orlando, FL. It promises to be a dynamic gathering of thought leaders and innovators, and Perficient is bringing a strong presence with four featured sessions that showcase our expertise in experience design, strategy, digital marketing, and analytics to create end-to-end solutions that deliver exceptional results.

As you’re mapping out your agenda, make sure to schedule some time to stop by our booth to meet our team of Sitecore MVPs, strategists, and technologists and catch a live demo of Sitecore’s products and our AI acceleration tools. Curious about the Sitecore and Gradial partnership and how you can benefit from agentic marketing? Our team would be thrilled to discuss our thoughts on what this can mean for your organization.

What We’re Talking About and When

We’re excited to take the stage with both Encompass Health and Evergy this year! If you’re looking to harness the power of customer data, design more inclusive experiences, or lead through change, our sessions offer something for everyone.

Back by popular demand, the first ever Women in Digital event that Perficient proudly co-sponsored with Sitecore last year is quickly becoming a “must attend” event on the conference schedule. This year’s theme is Leading Through Change and once again, Perficient’s own Megan Jensen will moderate a panel of inspiring women to dive into this topic.

Women and allies alike are welcome to experience this unique opportunity to hear from remarkable women, network with peers, and enjoy breakfast. Register early to reserve your spot. We look forward to seeing you there!

Women in Digital: Leading Through Change

In a landscape reshaped by AI, rerouted customer journeys, and the collapse of traditional content-to-commerce paths, leadership demands agility, empathy, and vision. This intimate breakfast panel brings together trailblazing women from across the digital ecosystem to explore how they’re navigating transformation—scaling trust, driving innovation, and fostering inclusion in real time. Join us for a candid conversation on what it means to lead now, what’s next, and how we build the future together.

What’s Your Data Doing for You? Learn How to Harness the Power of Your Data With Sitecore CDP

Your company possesses valuable customer data, but are you using it strategically? Join Perficient’s Eric Sanner, solutions architect and 2x Sitecore MVP, along with a marketing leader from Midwest utility company Evergy, to discuss how the company utilizes Sitecore CDP to combine data from multiple sources into one flexible, powerful, easy-to-use platform. Learn how to breathe new life into marketing strategies by creating sophisticated segmentation that targets high-value customers. See how CDP and Personalize can give marketers autonomy while reducing costs.

Designing Inclusive Experiences for Everyone: Build a Better Journey Map on Sitecore

Explore common disability tropes and stereotypes, the intersection of accessibility and representation, and the importance of showing diversity in advertising, marketing, and media. In this session, you’ll learn about UX challenges for disabled users, brainstorm improvements, and collaboratively design a user journey that addresses the needs of a disabled persona. These insights will help shape your understanding of the Sitecore products and platforms that enable inclusive experiences.

Unveiling Encompass Health’s Digital Transformation: A Panel on Lessons Learned With a Bit of SaaS

Join Perficient’s Stephen Tynes, national Sitecore sales advisor, and Mark Ursino, Sitecore principal, as they team up with marketing leaders from Encompass Health to share the organization’s digital transformation journey. Learn how the organization approached patient and caretaker research, fostered internal collaboration, and managed change with IT to drive success. We’ll address the challenges encountered, the outcomes achieved, and touch upon key topics such as the Sitecore roadmap and strategy to move from on-prem XP to SaaS XM Cloud.

A Sitecore Platinum Partner, Ready to Support You

Perficient is a global AI-first consultancy helping clients move faster, engage smarter, and connect deeper with customers. We’re a Sitecore 2024 Practice Excellence Award – Global winner with specialties in XM Cloud, CDP/Personalize, OrderCloud, Content Hub, and XP.

We’ll be on-site throughout the event to connect, collaborate, and share how we’re helping organizations unlock the full potential of Sitecore. Whether you’re exploring a move to XM Cloud, looking to optimize your personalization strategy, or simply want to chat about the future of digital experience, we’re here to help you make the most of your Symposium experience.

Over the past few months, I have shared a couple of blogs exploring embedded personalization in Sitecore XM Cloud:

• Personalization in Sitecore XM Cloud: What’s New, What’s Different, and What It’s Built On! – where I introduced the out-of-the-box personalization capabilities in XM Cloud.
• Getting Started with Personalization in Sitecore XM Cloud: Enable, Extend, and Execute  – where I walked through how to set up personalization and begin using it effectively.

While XM Cloud embedded personalization (found within Pages) offers an excellent, out-of-the-box solution for common personalization needs, it has a key limitation: it restricts you to a predefined set of marketer-friendly conditions. This streamlined, page-variant-based approach is quick to implement for scenarios like localizing content by geography or targeting new vs. returning visitors, making it a great starting point for content authors.

The Need for a Deeper Personalization Engine

But here’s the limitation: XM Cloud is built for speed, scalability, and a smooth content authoring experience. It doesn’t let you create custom conditions inside Pages. In legacy Sitecore XP, developers could extend the rule engine with custom C# code. In XM Cloud, the design is different. For any personalization logic beyond basic, marketer-friendly, out-of-the-box rules (like device type or referrer), Sitecore directs you to its dedicated, cloud-native platform – Sitecore Personalize.

This is where the world of digital experience often demands logic that goes beyond these basic audience segments. When you need to personalize based on proprietary business rules, custom data streams, or complex, multi-touchpoint journeys, the embedded tools won’t suffice.

This is where Sitecore Personalize becomes essential. Personalize is a standalone, cloud-native personalization and decisioning engine built to handle advanced scenarios.

Sitecore Personalize: The Technical Extension

Personalize acts as the key to unlocking limitless personalization power within your XM Cloud solution.

• Custom Conditions: The most critical technical feature is the ability to define developer-written custom conditions. These conditions are authored in JavaScript within Personalize, built once by a developer, and then exposed to marketers for endless reuse within the XM Cloud Pages audience builder. This allows you to create highly tailored audience rules based on any data you can pipe into the platform.
• Advanced Decisioning and Experimentation: Personalize is API-first, supporting complex decision models, A/B testing, and multi-variant experiments that can go far beyond simple page variants. It includes dedicated dashboards and robust analytics for measuring the performance of these sophisticated experiences.
• Cross-Channel Orchestration: Personalize is designed to be truly cross-channel. Its capabilities extend beyond just the website, enabling you to orchestrate consistent, personalized experiences across email, mobile apps, and other API-driven touchpoints—leveraging a unified profile of the customer.

In short, Personalize extends XM Cloud’s personalization boundaries, making it possible to design highly tailored user journeys without being locked into out-of-the-box conditions.

This blog is the next step in the series: a developer-friendly deep dive into how Personalize works with XM Cloud.

XM Cloud and Personalize Integration

The seamless delivery of personalized content relies on a robust technical connection between your XM Cloud content management environment and the Sitecore Personalize decision engine. This part often feels like “black box magic,” so let’s clarify the two key phases: initial provisioning and run-time execution.

Provisioning & Tenant Setup

When an organization purchases a Sitecore Personalize license, the initial setup is managed by Sitecore Professional Services or your dedicated implementation partner. This process ensures the two separate cloud products are securely linked.

The typical process involves:

• Tenant Mapping: Establishing a clear connection between your environments (e.g., XM Cloud Dev/Test connecting to a Non-Production Personalize tenant, and XM Cloud Production connecting to a Production Personalize tenant). This separation is crucial for ensuring you don’t mix test audiences and conditions with real production traffic.
• Portal Access: You’ll receive invites to both the Sitecore Cloud Portal and the Personalize portal.
• Analytics Identifier Configuration: Analytics Identifier must be created and mapped within XM Cloud for your website and this enables personalization.

Runtime Architecture: How the Two Talk at Request Time

Once environments are provisioned, your XM Cloud rendering host (typically a Next.js application) needs to fetch the correct personalization decision for every page request.

The Sitecore Cloud SDK is the exclusive and recommended method for integrating personalization and A/B/n testing within JSS SDK Next.js applications hosted on XM Cloud. This is designed to leverage Next.js Middleware and server-side rendering (SSR) for optimal performance. But let us take a look at both the SDKs that can be used to integrate with Personalize:

Personalization Data Flow Summary (SSR/Edge)

The personalization flow for a dynamic (SSR/Edge) page is a server-side handshake orchestrated by the Next.js Middleware and the Cloud SDK:

• Initial Check (JSS/Next.js $\to$ Experience Edge): The Next.js Middleware first queries Experience Edge to verify if any personalization variants exist for the page.
• Decisioning Call (JSS/Next.js $\to$ Personalize): If variants are found, the Middleware uses the Cloud SDK to send the visitor’s context to Sitecore Personalize.
• Variant ID Returned (Personalize $\to$ JSS/Next.js): Personalize evaluates all rules and returns the winning Variant ID (or the default ID) based on the evaluated rules.
• Content Fetch (JSS/Next.js $\to$ Experience Edge): The rendering host then makes a second request to Experience Edge, fetching the specific content layout matching the winning Variant ID.
• Final Delivery: The fully personalized HTML is rendered on the server and delivered to the visitor, ensuring a flicker-free experience.

Static Site Generation (SSG) Personalization Flow

The personalization process for pages built with SSG differs slightly from SSR to gain performance benefits by leveraging pre-generated HTML:

• Initial Request: When a visitor requests an SSG page, the Next.js application receives the standard HTTP request details (cookies, headers).
• Pre-Render Check: The Personalize middleware first checks its cache to see if static HTML variants have already been pre-rendered for this page.If a static variant is found, the middleware skips the initial API query to Experience Edge, speeding up the process. If no static variants are found, the process falls back to the standard SSR flow to dynamically fetch personalized variants from the CMS/Edge.
• Audience Decision: Assuming variants exist, the middleware sends a request to the Personalize (via the Cloud SDK) to identify which audience the current visitor belongs to.
• Delivery:
  • If the visitor matches an audience and that variant was already pre-generated, the middleware simply returns the cached static HTML for the personalized variant immediately.
  • If the visitor matches an audience but the static variant has not yet been built, the Next.js application generates the page variant HTML on the fly and then caches that output to serve as a static asset for all future visitors belonging to that same audience.
  • If the visitor does not match any defined audience, the generic default static HTML page is returned.

This method allows high-traffic personalized pages to benefit from the speed of static hosting after the first request generates the variant HTML.

Wrapping Up

Bringing Sitecore XM Cloud and Sitecore Personalize together creates a powerful framework for delivering experiences that adapt in real time. While XM Cloud manages structured content and headless delivery, Personalize adds a decisioning layer that evaluates context, behaviors, and data signals to tailor each interaction.

This integration not only extends the personalization capabilities of XM Cloud beyond static rules but also enables continuous testing, optimization, and experimentation. For teams building modern digital experiences, this approach provides the agility to serve relevant, data-driven content at scale – while maintaining the flexibility of a cloud-native, headless architecture.

In my next blog, I’ll walk through creating custom conditions in Sitecore Personalize, so you can define personalization logic that truly aligns with the unique business needs.

Sitecore has long positioned itself as a leader in composable digital experience platforms, offering flexibility and scalability for organizations looking to tailor their tech stacks. As AI becomes a central force in experience delivery, Sitecore is embedding agentic and Generative AI capabilities to help brands personalize at scale, streamline operations, and empower practitioners. 

Forrester’s report, The Impact of AI on Digital Experience Platforms, discusses how vendors like Sitecore are evolving their platforms to support intelligent orchestration and content creation. Sitecore’s modular architecture makes it uniquely suited to adopt these innovations. 

Empowering Practitioners With Agentic AI

Sitecore’s copilot launched in late 2024 and is designed to help marketers build hyper-personalized campaigns with less manual effort. These intelligent agents assist with segmentation, content recommendations, and campaign optimization all while integrating seamlessly into Sitecore’s composable stack. 

Perficient Sitecore Consulting Principal Mark Ursino has seen growing interest in Sitecore’s agentic AI capabilities, especially among clients looking to unify customer data and reduce friction in campaign execution. 

Ursino said, ” Sitecore’s AI orchestration capability, Stream, launched in late 2024 and is helping marketers move faster and smarter. We’re working with clients to integrate these tools into their workflows so they can focus on strategy while AI handles the complexity.” 

GenAI in a Composable World

Sitecore’s GenAI features are designed to complement its modular approach. Whether generating brand-consistent content, summarizing customer interactions, or supporting A/B testing, GenAI is helping teams deliver more relevant experiences without overhauling their existing infrastructure. 

“Sitecore’s composable architecture makes it easier to plug in GenAI capabilities where they’ll have the most impact. We’re helping clients identify those opportunities and align them with measurable goals,” said Ursino.  

Perficient Named 2025 Gold Globee® Winner for Best Artificial Intelligence Service Provider | Learn More 

Building a Responsible AI Foundation

Successful AI adoption requires more than just new features. Organizations must invest in strong data foundations, human oversight, and change management. That’s why we partner with clients to ensure these pillars are in place, especially when integrating AI into modular environments like Sitecore. 

We’re honored to have contributed to the research in an interview for Forrester’s report , The Impact of AI on Digital Experience Platforms. We believe it reflects our deep expertise in helping enterprise clients implement and optimize DXPs like Sitecore. Whether it’s orchestrating personalized journeys or deploying intelligent agents, we’re helping brands embrace AI responsibly and effectively. 

If you’re exploring how to bring AI into your DXP strategy, we invite you to connect with us and keep the conversation going. 

Access the report here (available to Forrester subscribers or for purchase).  

Learn more about our Sitecore expertise here.  

Contact us to learn more.