Maybe you’ve already made the switch to XM Cloud, or maybe you’re still evaluating it as the answer to all your digital delivery challenges. Spoiler alert: it won’t magically solve everything — but with the right setup and smart optimizations, it can absolutely deliver fast, scalable, and maintainable experiences.

If you’re using Sitecore Headless with Next.js, you’re already building on a modern and flexible foundation. Add in a deployment platform like Vercel, and you’ve got serious power at your fingertips. But unlocking that potential requires knowing where to fine-tune — both at the application and platform level.

Streamline Your Layout and API Payloads

The Sitecore Layout Service is versatile but can return bulky JSON payloads if left unchecked. Clean up your responses by:

• Removing unused placeholders and renderings

• Filtering out internal tracking or analytics fields unless explicitly needed

• Configuring the Layout Service to tailor the response to your frontend needs

If you’re using Sitecore Search or XM Cloud with GraphQL, concise queries will help keep your pages fast and predictable

• Request only the fields you need

• Use first: or limit: to control result size

• Organize queries into reusable fragments for maintainability and performance

Smaller payloads result in faster hydration, quicker time-to-interactive, and lower bandwidth usage — all especially valuable for mobile-heavy audiences.

Use Webhooks for Smarter Publishing (On-demand Revalidation or ODR)

Don’t rely on manual rebuilds or blanket cache clears. XM Cloud supports webhooks on publish, which opens the door to smarter automation:

• Trigger on-demand ISR revalidation for updated pages

• Push new content to Edge Config, CDNs, or search indexes

• Notify external systems (e.g., analytics, commerce, personalization) immediately

It’s the best way to keep content fresh without sacrificing performance or rebuilding the entire site.

Choose the Right Rendering Method: SSR, SSG, or ISR?

Not every page needs to be dynamic, and not every page should be static. Picking the right rendering strategy is critical — especially in a Sitecore headless app where you’re mixing marketing content with personalization and real-time updates.

Here’s how to decide:

Use SSR (Server-Side Rendering) when:

• The page depends on the user session or request (e.g., personalization, authenticated pages)

• You’re rendering in preview mode for content authors

Use SSG (Static Site Generation) when:

• The content rarely changes (e.g., static landing pages or campaigns)

• You want instant load times and no server cost

Use ISR (Incremental Static Regeneration) when:

• Content changes periodically, but not per-request

• You want to combine the speed of static with the freshness of dynamic

Use next/link with Prefetching

If you’re still using regular <a> tags or not thinking about navigation performance, this one’s for you. The next/link component enables fast, client-side routing and automatic prefetching of pages in the background.

Example:

import Link from 'next/link';

<Link href="/products" prefetch={true}>About Us</Link>

• Use it for all internal links

• Set prefetch={true} on high-priority routes

• Check behavior in your browser’s network tab — look for .json page data being fetched in advance

This alone can make your site feel instantly faster to users.

Optimize Fonts with next/font

Sitecore headless apps don’t include next/font by default, but it’s worth integrating. It allows you to self-host fonts in a performance-optimized way and avoid layout shifts.

Example:

import { Inter } from 'next/font/google';

const inter = Inter({ subsets: ['latin'] });

Apply fonts globally or per-page to improve loading consistency and avoid FOUT (Flash of Unstyled Text). Better fonts = better user experience.

Clean Up Your Codebase

Performance isn’t just about server-side logic — it’s also about keeping your codebase lean and clean.

What to review:

• Old personalization plugins that are no longer used

• Middleware that’s too permissive or generic in its matching

• Outdated multisite logic if you’ve already split into multiple Vercel projects

• Unused components or fetch logic in shared utilities

Use Vercel performance insights to track slow routes and spot cold starts.

Enable Fluid Compute

Fluid Compute lets Vercel reuse idle time across your serverless functions. That means better performance and lower costs — without any code changes.

To enable it:

• Go to your Vercel project settings

• Navigate to Functions

• Toggle Fluid Compute on

You can monitor the impact under Observability → Logs in your dashboard. It’s a low-effort win. Read more details about Fluid Compute in my previous blog!

Be Selective with Middleware

Next.js middleware is powerful but potentially expensive in performance terms. Use it wisely:

• Limit middleware to only essential routes

• Avoid using fetch() inside middleware — use Edge Config instead

• Replace multisite plugins with separate Vercel projects

• Audit unused or legacy logic, especially leftover personalization

Track middleware behavior through the Middleware tab in Vercel Logs.

Manage Redirects with Edge Config

For the fastest possible redirects, manage them directly in Vercel using Edge Config. This keeps Sitecore out of the request path and ensures instant resolution at the edge.

• Store all redirect data in Edge Config
• Deploy updates as part of your app or via external config tools
• Avoid real-time fetches from Sitecore for redirect logic

If you’re managing a large volume of redirects, consider using a bloom filter to optimize memory usage. Just note that bloom filters introduce a small delay due to redirect verification.

Conclusion

Optimizing a Sitecore Headless application, especially one deployed on Vercel, is about making dozens of small, smart decisions that add up to big wins in performance, scalability, and developer happiness. Whether it’s pruning your Layout Service output or toggling a setting in your Vercel dashboard, each move brings you closer to a faster, more responsive site.

XM Cloud doesn’t come pre-optimized — but that’s actually a good thing. It gives you the power and flexibility to build the way you want. Just make sure you’re building it right.

Optimization Checklist

Sitecore & XM Cloud

• Prune Layout Service JSON (remove unused placeholders and fields)

• Use GraphQL efficiently (limit queries, use fragments)

• Set up publish webhooks for on-demand rendering or cache purging

Rendering Strategy

• Use SSR for personalized/authenticated content

• Use SSG for static pages

• Use ISR for hybrid performance/freshness

Next.js

• Replace <a> with next/link and enable prefetching

• Add next/font for consistent and fast font rendering

Vercel

• Enable Fluid Compute for better serverless efficiency

• Use middleware only where necessary and avoid fetch inside

• Use Edge Config for fast redirect handling

• Monitor logs and performance insights for slow routes and cold starts

In my previous blog https://blogs.perficient.com/2024/07/01/sitecore-personalize-close-event-logic/, I shared a method for using cookies to enable the user to dismiss an alert banner.  This process involved writing the cookie when the user clicks the close icon and checking for the cookie when the experience is displayed.  This approach worked well because the entirety of the javascript code could be stored in the web template.  This ensures the code to check for the cookie can’t be missed or forgotten when the template was used.  Unfortunately, this had an unintended side effect.  Personalize still executed the experience and counted it in the analytics and performance metrics even though the javascript never added the elements to the screen.  This lead to overinflated metrics and the inability to use the data for accurate forecasting.  This problem can be overcome with advanced page targeting.

Advanced Page Targeting

Advanced page targeting allows you to run client side javascript to decide if an experience should execute.  Since the javascript runs client side, you can read the url and query string parameters, you can access the console to log messages, you can access the document object to query selectors on the page, and of course read cookies.  Advanced page targeting javascript runs after the page loads, but before the experience loads which allows us to prevent the experience from executing and overinflating analytics.  Be sure to keep your script as lean and performant as possible to reduce the possible screen flicker of loading the experience after the page has loaded.

Checking Cookies with Advanced Page Targeting

In order to use advanced page targeting, you must select the “specific pages” setting under “Page Targeting”.

Enable page targeting on specific pages to enable advanced page targeting

In the flyout window for page targeting, add any filters for pages where you want the experience to display.  If you want the experience to display on all pages, simply use the contains “/” rule.  In the advanced targeting section, click the “add script” button.

Configure advanced page targeting

In the advanced targeting code editor, enter the following code.

(function() {
   // console.log(new Error().stack);

    var cookies = document.cookie.split(';');
    for (var i = 0; i < cookies.length; i++) {
        var cookie = cookies[i].trim();
        if (cookie.indexOf('pers-' + selectedVariant.ref + '=clicked') === 0) {
            return false;
        }
    }

    targetingPassed();
})();

In my previous blog, I created the cookie using the variant.ref as part of the cookie name.  This adds the guid of the current experience id to the name of the cookie making it unique even when the web template was reused.  Advanced targeting does not have access to the variant.ref property.  So it doesn’t work with the close event logic idea I came up with before.  However, there is a selectedVariant.ref property that you can use.  Using selectedVariant.ref works for both experiences and experiments as it can dynamically get the correct guid of the current variant at run time.

When personalize evaluates this block of javascript code, it only continues processing the flow of execution for the experience if the “targetingPassed()” function is called.  If you want to stop the flow of execution, return false.  In our case, we want to stop the flow of execution if the cookie is found.  Otherwise we can call the targetingPassed() function and allow the experience to display to the user.

Once you have added advanced targeting javascript, you can edit the script by clicking the pencil icon.

Edit advanced page targeting settings

Edit advanced page targeting script

Things to Know About Advanced Page Targeting

As mentioned, this solution solves the problem of overinflating analytics.  The downside is the advanced page targeting settings and code cannot be saved with the web template.  So the marketer or content author must remember to enable this setting and add the javascript code to the experience.  If the code is not added, the user will be able to close the experience, but it will display on the next page load since the code to check for the cookie is missing.  One other thing to note, if you change your page targeting settings back to “all pages”, the advanced targeting script is deleted from the experience.  In both cases, ensure that it is easy for content authors to find and reuse.

In my previous blog – Personalization in Sitecore XM Cloud: What’s New, What’s Different, and What It’s Built On!, I explored what makes personalization in Sitecore XM Cloud so powerful – from its cloud-native infrastructure and headless architecture to the built-in rule-based targeting engine. Now, I’m shifting from concepts to implementation. In this post, I’ll walk you through how to enable personalization using analytics identifiers that track and categorize visitor behavior in real time. Then, I’ll show how to use Page Builder to create audience-specific page variants, and personalize components – all with a few clicks, not code.

In Sitecore XM Cloud, personalization happens primarily at the page level. The process revolves around creating page variants and personalizing components. This functionality is fully integrated into Page Builder, allowing you to define variations of the page based on different personalization criteria.

Key Points:

• Personalization is configured directly within Page Builder on a per-page basis.
• You can create page variants – each tailored to specific audiences or conditions.
  • Individual components on the page can be personalized : swapped, hidden and can be edited to show different content
• All of this is managed via the Personalize tab available on the page within Page Builder.

How to Check if Personalization is Enabled:

To determine whether personalization is set up:

• Go to the Page Builder for the desired page.
• Click on the Personalize tab.

If personalization is not enabled, you will see :

• No variant options available.
• A prompt or empty state indicating no personalization rules are define.

If personalization is enabled, you’ll see:

• Variants listed based on configured rules.
• Options to add/edit rules and personalize individual components.

Adding Analytics Identifiers to Enable Personalization

Analytics identifiers are essential for enabling personalization in Sitecore XM Cloud. They help track visitors, manage sessions, and unify data across sites for a complete view of user behavior. Without them, personalization rules and targeted content delivery won’t function. Assigning the same identifier to multiple sites allows for consolidated analytics, providing a holistic view of user engagement across different sites.

Step 1: Access Site Settings

1. Navigate to the XM Cloud Portal: Log in to your XM Cloud environment.
2. Open the Sites Dashboard: In the top navigation bar, click on Sites to view all your sites.
3. Select the Desired Site: Locate the site you wish to configure. Click on the Actions menu (three dots) associated with that site and select Settings.
4. Select the Site hosts: Browse through the options on the left side and select Site hosts option and then select the desired host

Step 2: Add or Assign an Analytics Identifier

1. Navigate to the Analytics and Personalization Tab: Within the site settings, click on the Analytics and Personalization tab.
2. Add Identifier for a Language: In the list of languages associated with the site, click the plus (+) icon next to the language you want to configure

Step 3: Choose Identifier Type:

• • Create a New Identifier: Select the Create new tab.
    • Name the Identifier: Provide a unique name for the analytics identifier.
    • Set Session Timeout: Define the session timeout duration (default is 30 minutes).
  • Assign an Existing Identifier: Select the Assign existing tab.
    • Select Identifier: Choose from the list of existing identifiers available in your environment.

Let’s Personalize a Page in Sitecore XM Cloud

1. Navigate to the Page in the Page Builder

• From the XM Cloud portal, open your site and select the page you want to personalize.
• Once it loads in Page Builder, you’ll see a “Personalize” tab at the top navigation bar if personalization is enabled.

2. Create a Page Variant

• Click on the Personalize tab.
• Select Create Variant.
• Provide a name for the variant (e.g. “Every Monday Campaign”)

• Click Next to proceed to audience configuration.

3. Define the Audience for the Variant

Click Add first condition to define who should see this variant.

Choose from the available conditions such of different tags

• Configure the selected condition using the provided fields.

• You can add multiple conditions using AND/OR logic.

4. Customize the Variant

• Once you click on Save, your variant is created and the audience is defined, you can now edit the variant.
• On the side is a screenshot of the Page Builder that lists down all that we can do with personalization on the page.

• You’ll see a color-coded border or indicator showing that you’re editing a personalized version.
• Each change you make is isolated to that variant and won’t affect the default view.

5. Preview the Variant

• Use the Preview feature to see what the page will look like for the targeted audience.

6. Publish the Variant

• When satisfied, click Publish to activate your personalized variant.
• Sitecore XM Cloud will now automatically show the appropriate variant to users matching the defined audience.

Personalization in Sitecore XM Cloud isn’t just a feature – it’s a strategic advantage. By enabling analytics identifiers and using Page Builder to create tailored experiences, you can deliver the right content to the right audience at the right time. With this setup in place, you’re well on your way to building smarter, more engaging digital experiences.

In the next blog, I’ll take you behind the scenes of how personalized content is actually delivered in Sitecore XM Cloud. We’ll explore the request lifecycle, how the Cloud SDK plays a role in fetching and rendering personalized variants, and the technical flow that powers real-time targeting. This deeper dive will help you understand not just what personalization looks like, but how it works under the hood.

In this post, I’ve listed the most commonly used Sitecore PowerShell commands for content migration. This blog continues from my earlier post: Sitecore XM Cloud Content Migration: Plan and Strategy.

During migration, we created several PowerShell scripts to extract data from the legacy database to CSVs. We then used those CSVs to import content into XM Cloud instances. Based on those scripts, I organized the commands into two groups: Working with Sitecore items and Working with Sitecore renderings. These commands aim to help developers handle similar Sitecore to XM Cloud migrations.

The command snippets are also available as a public GitHub Gist – Most widely used PowerShell SPE commands in Sitecore XM Cloud content migration

Working With Sitecore Items

Create a New Item Using the Template ID

$item = New-Item -Path $path -Name $itemName -ItemType $itemTemplateId -Language "en"

Sometimes, you may need to create an item with the same ID as in the legacy system to avoid numerous reconfigurations. Especially if those items are being used as the data source. In such a use case, we could use CreateItem from Sitecore.Data.Managers.ItemManager. This method takes the item name, parent item, template ID, and item ID. The passed $id will be the ID of the newly created Sitecore Item. 

$item = [Sitecore.Data.Managers.ItemManager]::CreateItem($name, $parentItem, $templateItem.ID, $id)

Also, there is a ForceId param supported by the ‘New Item‘ function

New-Item -Path $path -Name $name -ItemType "Blog Page" -ForceId "3904b0bf-b10b-4fbb-9ced-3de87dfa3d48"

Create a New Item Using the Branch Template

$item = [Sitecore.Data.Managers.ItemManager]::AddFromTemplate($itemName, $branchTemplateId, $parentItem)

Checking if the Path Exists in the Content Tree

In use cases, we need to check whether the path exists before creating an item on that path. 

$pathExists = Test-Path -Path $path
if($pathExists)
{
  //logic
}

Copying Items

Copy-Item -Path $sourcePath -Destination $targetPath

Working with Sitecore Renderings

Get All Renderings for an Item

This script was used to analyze an item’s legacy renderings, map them with new XM cloud renderings (components), and map fields. 

$item = Get-Item -Path $path -Version "latest"
$resultObj = @()
$defaultLayout = Get-LayoutDevice "Default"
Get-Rendering -Item $item -Device $defaultLayout -FinalLayout | ForEach {
    $renderingItem = Get-Item -Path master: -ID $_.ItemID
    $Obj = @{
        RenderingName =  $renderingItem.Name
        RenderingId =  $_.ItemID
        DataSource = $_.Datasource
        Placeholder = $_.Placeholder
        PageItem = $_.OwnerItemID
}
    $resultObj += New-Object psobject -Property $Obj
}
$resultObj | Format-Table RenderingName, RenderingId, DataSource, Placeholder, PageItem

Create and Set Rendering for an Item

When importing data from CSV, we often need to create and set a data source to render an item.  For this use case, I created a function that takes the rendering ID, the placeholder to add the rendering, and the data source ID. 

function CreateAndSetRendering{
    param([String]$id,[String]$placeholder,[String]$dsid
        )
        
        $renderingId = [Sitecore.Data.ID]::Parse($id)
        $rendering = get-item -path master: -id $renderingId
        $renderinginstance = $rendering | new-rendering -placeholder $placeholder
        if($dsid -ne "")
        {
            $datasourceId = [Sitecore.Data.ID]::Parse($dsid)
            $renderinginstance.datasource = $datasourceId
        }
        add-rendering -item $item -placeholder $placeholder -instance $renderinginstance -finallayout
        $item.editing.beginedit()
        $item.editing.endedit() | out-null
}

Retrieve the Rendering and Remove From the Presentation

{3904b0bf-b10b-4fbb-9ced-3de87dfa3d48} is the Sitecore Item ID of the rendering item we wish to retrieve

$defaultLayout = Get-LayoutDevice "Default"
$rendering = Get-Rendering -Item $item -Device $defaultLayout -FinalLayout | Where-Object { $_.ItemID -eq "{3904b0bf-b10b-4fbb-9ced-3de87dfa3d48}"}
Remove-Rendering -Item $item -Instance $rendering -Device $defaultLayout -FinalLayout

Getting a Specific Rendering Parameter Value

$paraName is the rendering parameter name, for example, “Styles”.

$rendering = Get-Item -Path master: -Id "{3904b0bf-b10b-4fbb-9ced-3de87dfa3d48}"
$renderingItem = Get-Rendering -Item $item -Device $defaultLayout -Rendering $rendering -FinalLayout
$parameterValue = Get-RenderingParameter -Rendering $renderingItem -Name $paramName

Updating Rendering Parameter Value

If there are more than one rendering of the same type, the returned $renderingItem will be an array so you can access the first rendering parameters $renderingItem[0].Parameters: This will return all parameters, and then you will have to check for a specific parameter.

$rendering = Get-Item -Path master: -Id "{3904b0bf-b10b-4fbb-9ced-3de87dfa3d48}"
$renderingItem = Get-Rendering -Item $item -Device $defaultLayout -Rendering $rendering -FinalLayout
$renedringParams = $renderingItem[0].Parameters
$styles = "Styles"
 if ($renedringParams.Contains($styles)) {
      $renedringParams = @{
            Styles = "%7B3904b0bf-b10b-4fbb-9ced-3de87dfa3d48%7D"
    }
    }
Set-RenderingParameter -Instance $renderingItem[0] -Parameter $renedringParams | Out-Null
Set-Rendering -Item $item -Instance $renderingItem[0] -FinalLayout

Note: We must embed Sitecore ID for your required style between %7B and %7D. For multiple values, the separator is %7D%7C%7B. It’s how Sitecore stores params values.

You can store multiple values like this: Styles = “%7B3904b0bf-b10b-4fbb-9ced-3de87dfa3d48%7D%7C%7B936219ee-a03b-49c5-8eff-8b877b5c1319%7D”

Conclusion

So, this is the consolidated list of Sitecore PowerShell commands for content migration. The IDs used in the above snippets were not valid Sitecore item IDs. Replace them with valid Sitecore item IDs based on the Sitecore items used in your project.

Keep learning!

Sitecore XM cloud content migration can be approached in various ways. The first thing that comes to mind when working on the Sitecore upgrade project to XM Cloud is content migration. Choosing the right method helps reduce migration time and avoid errors. I will outline the approach that best meets our client’s needs in this blog. We were provided with a master database backup that had all the content. Our task was to move Sitecore data, including media, from Sitecore 9.3 to XM Cloud.

We connected the legacy Sitecore database to the XM Cloud instance for migration. My colleague Martin Miles wrote a detailed blog on XM Cloud content migration: connecting the external database

Sitecore Items Data Migration to XM Cloud

Extracting items and their field data was relatively straightforward. We used PowerShell scripts to export item field data into CSV files. These CSVs were later imported into the XM Cloud using import scripts, building different page types.

We chose this approach due to a complete redesign of templates and renderings. The new XM Cloud setup did not reuse old templates, fields, or renderings. XM Cloud included fresh templates, fields, and renderings. This allowed us to map legacy page templates and fields to the new XM Cloud templates. This mapping helped us to import field values for different page types accordingly.

Our import scripts created key page types and populated the fields using field mappings. We created some standardized renderings for key page templates like Rich Texts, Accordion, etc. The scripts assigned data sources automatically to save content authors’ time. Only a few pages, like home, landing, and search, were created manually, which were unique. Most other pages were created using automation scripts.

XM Cloud runs in Docker containers in the local environment. So, we couldn’t access CSV files directly from the local file system. However, we have this covered by copying CSVs into \docker\deploy\platform\App_Data. This folder is part of the project’s root directory. These CSVs then became accessible within the local XM Cloud instance. We leveraged Sitecore Package Designer to package the CSV files to be installed in higher environments to run import scripts.

Media Migration to XM Cloud

We already have a legacy Sitecore database connected to the XM Cloud instance. Using Sitecore’s out-of-the-box UI for bulk content migration between databases, we locally transferred media from the legacy database to the XM Cloud.

Once the media folder with all the subfolders moved to XM Cloud, we have used a script to create media packages. My colleague Nick has written thorough blog on Exporting Media Items with Sitecore PowerShell Extensions to create packages of media.

The number of media packages depends on your database size. We had approximately 5GB of media items to migrate, so we created around 190 media packages for this migration. Package count also depends on the size of each media package. We limited each media package size to 25MB. Larger media packages take more time to upload and install. Sometimes, big packages get stuck without showing installation progress, which is frustrating.

In higher environments, we used the script below to upload and install the packages created locally.

$filepath = Receive-File -Path "C:\inetpub\wwwroot\App_Data\packages\"
Write-Host "Uploaded package Succesfully : " $filepath

# get file size in MB in PowerShell   
$size = (Get-Item -Path $filepath).Length/1MB
Write-Host $size "MB"
Write-Host "Installation Started......"
Install-Package -Path $filepath -InstallMode Merge -MergeMode Merge
Write-Host "Installation Completed - Package installed successfully"

In this way, we had migrated a whole media library to XM Cloud. This process was tedious and took a day to create and upload all packages.

I am sharing sample PowerShell scripts for extracting and importing Sitecore item data. The Sitecore IDs used in the scripts are not valid; you need to replace them as per your project’s Sitecore item IDs.

The PowerShell scripts are also available as a public GitHub Gist Export-Import SitecoreItemData SPE Scripts

Sitecore Item Data Extraction Script

<#
    .SYNOPSIS
       Generic Page data extraction
        
    .DESCRIPTION
        Gets Sitecore Items from legacy database and extracts field values.
        List could be exported to csv by OOTB feature of List View in SPE.
        
    .NOTES
        Akash Borkar | Perficient 
#>

function Write-LogExtended {
    param(
        [string]$Message,
        [System.ConsoleColor]$ForegroundColor = $host.UI.RawUI.ForegroundColor,
        [System.ConsoleColor]$BackgroundColor = $host.UI.RawUI.BackgroundColor
    )

    Write-Log -Object $message
    Write-Host -Object $message -ForegroundColor $ForegroundColor -BackgroundColor $backgroundColor
}

# Function for getting item names from pipe-separated item ids
function GetItemNamesFromIds {
    param(
        [System.String] $ids
    )
    
    if($ids.Contains("|"))
    {
        # Split the string by pipe and clean up each GUID
        $guids = $ids.Split("|") | ForEach-Object { $_.Trim(' {}') }
        [Sitecore.Text.ListString]$nameArr = ""

        foreach ($id in $guids) {
            $formattedId = "{0}{1}{2}" -f '{', $id, '}'
    
            $Id = [Sitecore.Data.ID]::Parse($formattedId) 
            $item = Get-Item -Path xyz: -ID $Id
                    
            if ($item -ne $null -and !$nameArr.Contains($item.Name)) {
                $nameArr.Add($item.Name) | Out-Null
            }
        }
        
        # Join the names with pipe separator and return the result
        $names = [System.String]::Join("|", $nameArr)
        return $names
    }
    else
    {
        $item = Get-Item -Path xyz: -ID $ids
            return $item.Name
    }
}

#Function for getting datasource item, which is further used for extracting field value & assigning to new rendering
function Get-DatasourceItem{
    param(
         [System.String] $path
        )
        $datasourceItem = $sourceDatabase.GetItem($path)
        return $datasourceItem
}


Write-LogExtended " "
Write-LogExtended "Generic Pages Data Extraction"
Write-LogExtended "-----------------------------------------------------------------"

$processedItems = [System.Collections.Generic.List[PSCustomObject]]::new()
$nonprocessedItems = [System.Collections.Generic.List[PSCustomObject]]::new()
$sourceDatabase = Get-Database "xyz"

$parentPath = Show-Input -Prompt "Please enter the Sitecore item path for getting children"
if($parentPath -ne $null)
{
    Write-Host "Selected path: $parentPath"

    #Get all child items based on provided path. /sitecore/content/XYZ/Home/Generic
    $nodePath = "xyz:" + $parentPath
    $items = Get-ChildItem -Path $nodePath -Recurse | Where-Object { $_.TemplateName -eq 'Generic Page'}
    
    Write-LogExtended "Total child items: $($items.Count)  Path: $($nodePath)" -ForegroundColor Green
    
    foreach($sourceItem in $items)
    {
        if($sourceItem -ne $null){
            
            #Retrieve RTE
            $rts = Get-Rendering -Item $sourceItem -Device $defaultLayout -FinalLayout | Where-Object { $_.ItemID -eq "{278F7B0D-98F4-4873-9B7B-940082158E4A}"}
            [Sitecore.Text.ListString]$rtArr = ""
            
            if($rts -ne $null)
            {
                foreach($rt in $rts)
                { 
                  $item = $sourceDatabase.GetItem($rt.Datasource)
                  if($item -ne $null -and $item["Text"] -ne "")
                  {
                      $rtArr.Add($item["Text"]) | Out-Null
                  }
                }
            }
            
            
            #Retrieve Accordion
            $accordion = Get-Rendering -Item $sourceItem -Device $defaultLayout -FinalLayout | Where-Object { $_.ItemID -eq "{165B5ECC-E6A0-4B41-AA23-D28FA5A9BF68}"}
            $accordionCount = 0
            [Sitecore.Text.ListString]$titleArr = ""
            [Sitecore.Text.ListString]$descArr = ""
            
            if($accordion -ne $null)
            {
                foreach ($renderingItem in $accordion) 
                {
                    if($renderingItem.Datasource -ne "")
                    {
                        $rendering = Get-Item -Path xyz: -Id $renderingItem.Datasource
                        if($rendering.HasChildren)
                        {
                            $accdChildItems = Get-ChildItem -Path xyz: -ID $rendering.ID
                            foreach($item in $accdChildItems)
                            {
                                if($item["Title"] -ne "" -and $item["Description"] -ne "")
                                {
                                      $titleArr.Add($item["Title"]) | Out-Null
                                      $descArr.Add($item["Description"]) | Out-Null
                                }
                            }
                        $accordionCount++;
                        }
                    }
                }
            }
                
            #Retrieve values of multilist field named Categories
            $categories = $sourceitem["Categories"]
            $categoriesnames = ""
            if($categories -ne "" -and $categories -ne $null)
            {
                $categoriesnames = GetItemNamesFromIds -ids $categories
            }
            
            
            try{
                $processedItems.Add(
                    [PSCustomObject]@{
                        Name = $sourceItem.Name
                        Id = $sourceItem.Id
                        Path = $sourceItem.Paths.FullPath
                        Title = $sourceItem["Title"]
                        HeaderTitle = $sourceItem["Header Title"]
                        Summary = $sourceItem["Summary"]
                        Image = $sourceItem["Image"]
                        OGImage = $sourceItem["Media Image"]
                        Categories = $categoriesnames
                        HasRTE = $rtArr.Count
                        RichText1 = $richText
                        RichText2 = $rtArr[1]
                        RichText3 = $rtArr[2]
                        
                        HasAccordion = $accordionCount
                        AccTitle1 = $titleArr[0]
                        AccDesc1 = $descArr[0]
                        AccTitle2 = $titleArr[1]
                        AccDesc2 = $descArr[1]
                        AccTitle3 = $titleArr[2]
                        AccDesc3 = $descArr[2]
                        AccTitle4 = $titleArr[3]
                        AccDesc4 = $descArr[3]
                        
                    }
                )
                        
            Write-LogExtended "Added data for $($sourceItem.Name), Path: $($sourceItem.Paths.FullPath) " -ForegroundColor Green
            }
            catch{
                Write-Host "Error occured" -BackgroundColor DarkRed
                            
                $nonprocessedItems.Add(
                    [PSCustomObject]@{
                        Name = $sourceItem.Name
                        Id = $sourceItem.Id
                        Path = $sourceItem.Paths.FullPath
                    }
                )
            }
        }
        else
        {
            Write-LogExtended "No Item found in csv for SourceURL: $($row.SourceURL)" -ForegroundColor RED
        }
    }
    
    $processedItems | Show-ListView -PageSize 15000 -Property  Name, Id, Path, Title, HeaderTitle, Summary, Categories, Image, OGImage, 
                                                                HasRTE, RichText1, RichText2, RichText3, HasAccordion, AccTitle1, AccDesc1, AccTitle2, AccDesc2, AccTitle3, 
 AccDesc3, AccTitle4, AccDesc4
                                                             
    $processedItems | export-csv -Path "C:\inetpub\wwwroot\App_Data\Process.csv" -NoTypeInformation                                                  
    $nonprocessedItems | Show-ListView -PageSize 15000 -Property  Name, Id, Path
}
else
{
        Write-Host "Path is not provided : $parentPath"
}

Sitecore Item Import Script

<#
    .SYNOPSIS
       Generic Pages Import
        
    .DESCRIPTION
        Iterate through CSV, create siteore items for generic pages and Populate fields. Generate List of processed and Non processed items.
        
    .NOTES
        Akash Borkar | Perficient 
#>

function Write-LogExtended {
    param(
        [string]$Message,
        [System.ConsoleColor]$ForegroundColor = $host.UI.RawUI.ForegroundColor,
        [System.ConsoleColor]$BackgroundColor = $host.UI.RawUI.BackgroundColor
    )

    Write-Log -Object $message
    Write-Host -Object $message -ForegroundColor $ForegroundColor -BackgroundColor $backgroundColor
}


Write-LogExtended " "
Write-LogExtended "Generic Pages Import"
Write-LogExtended "-----------------------------------------------------------------"

# Prompt for the file path
$filePath = Show-Input -Prompt "Please enter the full path to the CSV file"
if($filePath -ne $null)
{
Write-Host "Selected file: $filePath"

# Import the CSV file
$csvData = Import-Csv -Path $filePath | Where-Object { -join $_.psobject.Properties.Value }

Write-LogExtended "CSV file read successfully" -ForegroundColor Green

    if($csvData -ne $null)
    {
        $processedItems = [System.Collections.Generic.List[PSCustomObject]]::new()
        $NonProcessedItems = [System.Collections.Generic.List[PSCustomObject]]::new()
        $database = Get-Database "master"
        $placeholder = "/headless-main/container-1"
        
        foreach ($row in $csvData){
            
            #Generic Page branch
            $branchTemplateId = [Sitecore.Data.ID]::Parse("{8032FE9E-3CD1-4E80-8377-66BBF74F839E}")
            
            # Extract the desired item name, parent item and template id from the URL
            $itemName = $row.Name
            $parentItemPath = $row.Path -Replace $itemName, ""

            # Get the parent item
            $parentItem = $database.GetItem($parentItemPath)
            
            if ($parentItem){
                # Check if the item already exists
                $existingItemPath = "$($parentItem.Paths.FullPath)/$itemName"
                $itemExists = Test-Path -Path $existingItemPath
                
                if (-not $itemExists){
                    $item = [Sitecore.Data.Managers.ItemManager]::AddFromTemplate($itemName, $branchTemplateId, $parentItem)
                    
                    if ($item -eq $null) {
                    Write-LogExtended "Unable to create new item - $($itemName) - in Language en" -ForegroundColor Red
                    
                        $NonProcessedItems.Add(
                        [PSCustomObject]@{
                            ID = $row.ID
                            Name    = $row.Name
                            Path = $row.Path
                        })
                    }
                    
                    if($item -ne $null){
                        $item.Editing.BeginEdit()
                        
                        $item["Title"] = $row.Title
                        
                        #Meta Properties/OG
                        $item["OpenGraphTitle"] = $row.Title
                        $item["OpenGraphDescription"] = $row.Summary
                        $item["MetaDescription"] = $row.Summary
                        $item["TwitterDescription"] = $row.Summary 
                        $item["TwitterImage"] = $row.OGImage
                        
                        $item.Editing.EndEdit() | Out-Null
                        
                        
                        $datasourcePath =  $item.Paths.FullPath + "/Data/"
                        #Create and Populate Rich Text (Max RT are 3 as we had extracted 3 RTEs)
                        if($row.RichText1 -ne "")
                        {
                             For($i=1; $i -lt 4; $i++) 
                                { 
                                    $propname = "RichText$i"
                                    if($row.$propname -ne "")
                                    {
                                        $dsitem = New-Item -Path $datasourcePath -Name "Text $i" -ItemType "{4FBDBF79-C7D6-42F1-8048-D5E70D6167D5}"
                                        $dsitem.Editing.BeginEdit()
                                        $dsitem.Text =  $row.$propname
                                        $dsitem.Editing.EndEdit() | Out-Null
                                        
                                        #Create and Set Rich text Rendering
                                        $rendering = get-item -path master: -id {EF82E4AE-C274-40D4-837C-B3E1BF180CCC}
                                        $renderinginstance = $rendering | new-rendering -placeholder $placeholder
                                        $renderinginstance.datasource = $dsitem.id
                                        Add-Rendering -Item $item -placeholder $placeholder -instance $renderinginstance -finallayout
                                        $item.Editing.beginedit()
                                        $item.Editing.endedit() | out-null
                                    }
                                }
                        }
                        
                        
                        #Create and Populate Accrd datasource item (Max Acc are 4)
                        if($row.AccTitle1 -ne "" -and $row.AccDesc1 -ne "")
                        {
                            $accDatasourcePath =  $item.Paths.FullPath + "/Data/"
                            #Accordion
                            $Accitem = New-Item -Path $accDatasourcePath -Name "Accordion" -ItemType "{D482D45C-4248-46C8-BDD5-DE7C2255C52A}"
                            $Accitem.Editing.BeginEdit()
                            $Accitem.Title =  "Accordion"
                            $Accitem.Editing.EndEdit() | Out-Null
                            
                            #Create and Set Acc rendering
                            $rendering = Get-Item -Path master: -ID {3341A94D-42C9-4EE3-8A25-51D8B437982B} #Accordion
                            $renderingInstance = $rendering | New-Rendering -Placeholder $placeholder
                            $renderingInstance.Datasource = $Accitem.ID
                            Add-Rendering -Item $item -PlaceHolder $placeholder -Instance $renderingInstance -FinalLayout
                            
                            For($i=1; $i -lt 5; $i++) 
                            { 
                                $titlename = "AccTitle$i"
                                $descname = "AccDesc$i"
                                if($row.$titlename -ne "" -and $row.$descname -ne "")
                                {
                                    #Acc Panel
                                    $dsitem = New-Item -Path $Accitem.Paths.FullPath -Name $row.$titlename -ItemType "{B50C502C-2740-44C8-A63E-E9E4AF4BAA4B}"
                                    $dsitem.Editing.BeginEdit()
                                    $dsitem.Title =  $row.$titlename
                                    $dsitem.Content =  $row.$descname
                                    $dsitem.Editing.EndEdit() | Out-Null
                                    
                                    #Create and Set Acc panel rendering
                                    $rendering = Get-Item -Path master: -ID {7614DFFF-6735-4BA5-929A-A82FBC91DB25} #Acc Panel
                                    $renderingInstance = $rendering | New-Rendering -Placeholder "/headless-main/container-1/accordion-panels-1"
                                    $renderingInstance.Datasource = $dsitem.ID
                                    Add-Rendering -Item $item -PlaceHolder "/headless-main/container-1/accordion-panels-1" -Instance $renderingInstance -FinalLayout
                                    $item.Editing.BeginEdit()
                                    $item.Editing.EndEdit() | Out-Null
                                    
                                    Write-LogExtended "Added Accordion datasource to New Item - $($item.Name) at $($dsitem.Paths.FullPath)" -ForegroundColor Green
                                }
                            }
                        }
                        
                        $ManualWork = "No"
                        if(($row.HasRTE -gt 3) -or ($row.HasAccordion -gt 4))
                        {
                            $ManualWork = "Yes"
                        }
                        
                        Write-LogExtended "Created New Item - $($itemName) at $($parentItemPath)" -ForegroundColor Green
                        $processedItems.Add(
                        [PSCustomObject]@{
                            Name    = $item.Name
                            Id = $item.ID
                            NewPath = $item.Paths.FullPath
                            HasRTE = $row.HasRTE
                            HasAccordion = $row.HasAccordion
                            ManualWork = $ManualWork 
                        })
                    }
                }
                else 
                {
                    Write-LogExtended "Item $($itemName) already exists at $($parentItemPath) " -ForegroundColor Yellow
                }
            }
            else 
            {
                Write-LogExtended "Parent item not found: $parentItemPath" -ForegroundColor Red
            }
        }
        
    $processedItems | Show-ListView -PageSize 2000 -InfoTitle "Processed Items" -Property  Name, Id, NewPath, HasRTE, HasAccordion, ManualWork
        $processedItems | export-csv -Path "C:\inetpub\wwwroot\App_Data\GenericPagesReport.csv" -NoTypeInformation
    $NonProcessedItems | Show-ListView -PageSize 2000 -InfoTitle "Non Processed Items" -Property  ID, Name, Path
    }
}
else
{
    Write-Host "No file selected : $filePath"
}

I kept the script limited to extracting some fields and renderings; however, it gives a fair idea of how to extract data and import.

Conclusion

The PowerShell scripts you will write will be based on project requirements, template naming, rendering, and field mappings for your key page templates. When we first started migrating, we had a hard time figuring out the approach and connecting the dots. In this blog, I wanted to make sure the plan is clear. In my next blog Sitecore PowerShell commands – XM Cloud Content Migration, I will give the code snippets of the most widely used PSE commands used in Sitecore content migration.

Sitecore Connect is Sitecore’s low-code integration platform designed to easily automate workflows between Sitecore and external systems, without heavy custom coding. If you’re new to Sitecore Connect or want a deeper understanding of when and how to use it, check out these helpful resources:

• When to Choose Sitecore Connect: Solving Integration Challenges
• Understanding Sitecore Connect: Building Integrations with Recipes

In this practical example, we’ll demonstrate how to use Sitecore Connect together with OpenAI to send a page URL and fetch AI-generated meta tags (like meta title and meta description) to enrich the page’s SEO.

We will walk through:

• Setting up a connection to OpenAI using Sitecore Connect’s HTTP app
• Building a recipe that:
  • Triggers when a page is created or updated
  • Sends the page URL to OpenAI with a prompt asking for meta tags
  • Receives and processes AI-generated meta title and meta description

This approach enhances your content creation workflows by generating smart SEO metadata at scale, using minimal manual effort and maximum AI power.

Step 1: Creating a Connection with OpenAI

To start integrating OpenAI with Sitecore Connect, the first step is to create a connection using your OpenAI API key.

Follow these steps:

1. Obtain the API Key:
   • Login to your OpenAI account (such as through OpenAI portal).
   • Navigate to your account settings and generate an API key.
     (Keep this key safe as you will need it for authentication.)
2. Create a New Connection:
   • In Sitecore Connect, click on the Create Connection button.
3. Choose OpenAI from the App Library:
   • A list of available apps will be displayed.
   • Use the search bar to find “OpenAI” and select it.
   • Click on Create Connection.
4. Configure the Connection:
   • Enter the following details:
     • Name: Provide a meaningful name for your connection (e.g., “OpenAI Meta Tag Generator”).
     • Location: Select the workspace or folder where you want the connection saved.
     • API Key: Paste the API key you copied from your OpenAI account.
5. Authenticate and Test:
   • Click on the Connect button.
   • Sitecore Connect will attempt to authenticate with OpenAI using the provided API key.
   • If the authentication is successful, your connection will be created and ready to use.

With the OpenAI connection established, we can now move on to building a recipe to send page URLs and retrieve meta tag suggestions!

Step 2: Building the Recipe Function to Send Page URL and Fetch Meta Tags

Now that the connection to OpenAI is ready, let’s create a Recipe Function in Sitecore Connect.
This allows you to call the function from anywhere (like another recipe or an external system) by passing the page URL dynamically.

Follow these updated steps:

1. Create a New Recipe Function:
   • In Sitecore Connect, go to the Recipes section.
   • Click on Create Recipe.
   • In the trigger selection screen, choose Build a Recipe Function.
     (This creates a callable function, not a direct event-based recipe.)
2. Add Input Parameter for Page URL:
   • After creating the function, Sitecore Connect will prompt you to define input parameters.
   • Add a new parameter:
     • Name: Page URL
     • Type: Text / String
   • This parameter will allow the function to receive any page URL dynamically.
3. Select App and Action:
   • Once the function is ready, click on Add an Action.
   • The App Library will open.
   • Using the connection you created earlier,select OpenAI from the available apps.
4. Choose the Action Type:
   • After selecting OpenAI, you will see a list of available actions.
   • Select the Send a Message action.
   • It provides 2 options Single message and Chat transcript.
   • I chose Single Message as the message type for this case.
   • 

Now, in the Message Content to OpenAI, configure it carefully:

Prompt to OpenAI:

• Here, {Page URL} dynamically uses the Page URL input parameter you defined in Step 2.

This ensures that OpenAI receives the correct URL, understands the task, and responds in a structured JSON output ready for further processing.

After setting this message, you will be ready to handle and use the response in the next steps!

Step 3: Handling the OpenAI Response

Once OpenAI processes the URL and sends back a response, we need to parse the result and map it to usable fields inside Sitecore Connect.
This step ensures the meta title and meta description are correctly extracted and available for further use.

Follow these steps:

1. Parse the JSON Response:
   • After the OpenAI action, add a Parse JSON step.
   • Configure it to parse the body of the response you get from OpenAI.
   • Define the expected schema based on the format you instructed OpenAI to return:
   • {
   •   “meta_title”: “string”,
   •   “meta_description”: “string”
   • }
   • Sitecore Connect will now recognize meta_title and meta_description as separate variables you can use.
2. Use the Parsed Data:
   • After parsing, you can now:
     • Return the meta title and meta description as the output of the Recipe Function.
     • OR, if part of a larger automation, map these fields directly into your Sitecore items.
3. Test the Flow:
   • Use the Test function inside Sitecore Connect.
   • Provide a sample Page URL as input.
   • Run the recipe function and validate that:
     • OpenAI is called correctly.
     • The JSON response contains the expected meta title and meta description.
     • The fields are parsed and mapped properly.

Conclusion

By using Sitecore Connect and OpenAI together, you can create powerful, scalable automations that enhance your content operations.
In this example, it is showed how to send a page URL to OpenAI, fetch SEO metadata, and integrate it seamlessly into Sitecore workflows — all without writing heavy custom code.

This type of automation opens new possibilities for smarter, faster content management at enterprise scale.

In the ever-evolving world of web development, the term “headless” is as popular today as it ever has been. But what does it really mean, and why should you care? Let’s dive into the concept of headless architecture, its benefits, and why Sitecore is leading the charge in this space.

What is Headless?

At its core, a headless CMS is a software design approach that separates the front-end (what users see) from the back-end (where content is managed). Unlike traditional CMS platforms that tightly couple content management with presentation, headless CMS’s use APIs to deliver content anywhere—web, mobile app, kiosk, or a smart device. In many ways, the originator of headless architecture is Jamstack – which stands for JavaScript, APIs, and Markup. Instead of relying on traditional monolithic architectures, Jamstack applications decouple the web experience from the back-end, making them more scalable, flexible, and high-performing. JavaScript handles dynamic interactions on the front-end, allowing developers to build fast and modern user experiences. API’s provide a way to pull in content and services from various sources and the website can also push data to API’s such as form submissions, custom analytics events and other user driven data. Markup refers to pre-built HTML that can be served efficiently, often generated using static site generators or frameworks like Next.js.

Why Go Headless?

You might be wondering, “Why would I build my website entirely in JavaScript when it’s mostly content?” That’s a valid question and I thought the same when Sitecore JSS first came out. Headless though is less about “building your site in JavaScript” and more about the benefits of the architecture.

Flexibility

Headless CMS’s allow developers to work with any front-end framework they choose, whether it’s React, Vue, Angular, or whatever your favorite framework might be. This means teams are not locked into the templating system of a traditional CMS or the underlying backend technology.

Performance

Speed is everything in today’s digital landscape. Studies show that even a slight delay in page load time can significantly impact user engagement and conversion rates. Headless CMS’s improve performance by enabling static site generation (SSG) and incremental static regeneration (ISR)—both of which ensure lightning-fast load times. Instead of a server processing each request from a user, static content can be served from a global CDN – which is a modern composable architecture. Of course, server side rendering is also still an option and can also by very performant with the right caching strategy.

Omnichannel Delivery

Content today is consumed on more than just websites. Whether it’s a mobile app, smart device, digital kiosk, or even a wearable, headless architecture ensures content can be delivered anywhere through API’s. This makes it easier for brands to maintain a consistent digital experience across multiple platforms without duplicating content.

Security

Traditional CMS’s are often vulnerable to security threats because they expose both the content management system and the front-end to potential attacks. In contrast, headless CMS’s separate these layers, reducing the attack surface. With content served via APIs and front-end files hosted on secure CDNs, businesses benefit from enhanced security and fewer maintenance headaches.

Scalability

Handling high traffic volumes is a challenge for traditional CMS platforms, especially during peak times. Since headless solutions rely on cloud-based infrastructure, they can scale dynamically without requiring expensive hardware upgrades. Whether you’re serving thousands or millions of users, headless architecture ensures your site remains stable and responsive.

Why Sitecore for Headless?

There are plenty of options in the headless CMS market, but Sitecore offers a unique blend of features that make it stand out. With XM Cloud, Sitecore provides a fully SaaS-based solution—no more infrastructure headaches, no more costly upgrades, and uptime and reliability are now handled by Sitecore.

Sitecore’s hybrid headless approach allows organizations to transition at their own pace, leveraging the benefits of headless while maintaining familiar content management workflows. Hybrid headless gives content authors complete freedom and flexibility to build content however they’d like – where most purely headless content management systems are more rigid on how pages are built.

As digital experiences become more dynamic and user expectations continue to rise, headless CMS solutions offer the agility businesses need. If you’re looking to modernize your digital strategy, now is the time to embrace headless.

TLS certificate lifetimes are being significantly reduced over the next few years as part of an industry-wide push toward greater security and automation. Here’s the phased timeline currently in place:

• Now through March 15, 2026: Maximum lifetime is 398 days

• Starting March 15, 2026: Reduced to 200 days

• Starting March 15, 2027: Further reduced to 100 days

• Starting March 15, 2029: Reduced again to just 47 days

For teams managing Sitecore implementations, this is more than a policy shift—it introduces operational urgency. As certificates begin expiring more frequently, any reliance on manual tracking or last-minute renewals could result in costly downtime or broken integrations.

If your Sitecore environment includes secure endpoints, custom domains, or external integrations, now is the time to assess your certificate strategy and move toward automation.

Why This Matters for Sitecore

Sitecore projects often involve:

• Multiple environments (development, staging, production) with different certificates

• Custom domains or subdomains used for CDNs, APIs, headless apps, or marketing campaigns

• Third-party integrations that require secure connections

• Marketing and personalization features that rely on seamless uptime

A single expired certificate can lead to downtime, loss of customer trust, or failed integrations—any of which could severely impact your digital experience delivery.

Key Risks of Shorter TLS Lifetimes

• Increased risk of missed renewals if teams rely on manual tracking

• Broken environments due to expired certs in Azure, IIS, or Kubernetes configurations

• Delayed deployments when certificates must be re-issued last minute

• SEO and trust damage if browsers start flagging your site as insecure

How to Prepare Your Sitecore Project Teams

To stay ahead of the TLS certificate lifecycle changes, here are concrete steps you should take:

1. Inventory All TLS Certificates

• Audit all environments and domains using certificates

• Include internal services, custom endpoints, and non-production domains

• Use a centralized tracking tool (e.g., Azure Key Vault, HashiCorp Vault, or a certificate management platform)

2. Automate Certificate Renewals

• Wherever possible, switch to automated certificate issuance and renewal

• Use services like:

  • Azure App Service Managed Certificates

  • Let’s Encrypt with automation scripts

  • ACME protocol integrations for Kubernetes

• For Azure-hosted Sitecore instances, leverage Key Vault and App Gateway integrations

3. Establish Certificate Ownership

• Assign clear ownership of certificate management per environment or domain

• Document who is responsible for renewals and updates

• Add certificate health checks to your DevOps dashboards

4. Integrate Certificate Checks into CI/CD Pipelines

• Validate certificate validity before deployments

• Fail builds if certificates are nearing expiration

• Include certificate management tasks as part of environment provisioning

5. Educate Your Team

• Hold knowledge-sharing sessions with developers, infrastructure engineers, and marketers

• Make sure everyone understands the impact of expired certificates on the Sitecore experience

6. Test Expiry Scenarios

• Simulate certificate expiry in non-production environments

• Monitor behavior in Sitecore XP and XM environments, including CD and CM roles

• Validate external systems (e.g., CDNs, integrations, identity providers) against cert failures

Final Thoughts

TLS certificate management is no longer a “set it and forget it” task. With shorter lifetimes becoming the norm, proactive planning is essential to avoid downtime and ensure secure, uninterrupted experiences for your users.

Start by auditing your current certificates and work toward automating renewals. Make certificate monitoring part of your DevOps practice, and ensure your Sitecore teams are aware of the upcoming changes.

Action Items for This Week:

• Identify all TLS certificates in your Sitecore environments

• Document renewal dates and responsible owners

• Begin automating renewals for at least one domain

• Review Azure and Sitecore documentation for certificate integration options

Searching for content on the web has evolved from basic string based matches to a sophisticated array of approaches including keywords, stemming, synonyms, word order, regular expressions, weights and relevance.  Users expect the highest ranking results to be the most relevant and 75% of users don’t go past the first page of results.  All of these advanced techniques are great to find relevant content.  But sometimes you need to find an exact phrase with the specific words in a specific order.  Many search engines do this by wrapping quote marks around the “search term” to indicate an exact match search. Sitecore Search defaults to relevance based searches, but you can achieve exact match search with some configuration.

Understanding Sitecore Search

Let’s take a moment to remember a few concepts in Sitecore Search to understand the configuration better.

• Index Document – A single piece of indexed content such as a webpage, a word document, a pdf, etc.
• Attributes – The fields of an indexed document such as title, subtitle, url, content type, etc.
• Textual Relevance – Defines the attributes used to locate potential results.
• Weight – Defines a relative value for how important an attribute is within the textual relevance.
• Analyzers – Convert the original search query into a format that is optimized for search.
• Token – A chunk of the original search query, usually a single word or phrase that is often modified by the analyzer to include synonyms, remove stop words and reformat to the root word.

Sitecore Search has a number of predefined analyzers built in.  Each analyzer processes the search query in different ways.

The default analyzer is the multi local standard analyzer.  This analyzer modifies the search query by making it lower case, splitting the search query into single word tokens, finding the root of each word, applying synonyms, and removing punctuation.  For this reason, it will not find an exact match.  For that we need the keyword analyzer which leaves the search query in a single token without applying any modifications.

Configure Exact Match Search – Textual Relevance

In order to configure exact match search, we need to add the keyword analyzer to the textual relevance settings for the desired attribute, in this case the description.

Navigate to Admin/Domain Settings then click the feature configuration tab.

Domain Settings

Edit the Textual Relevance section.

Textual Relevance Settings

Add the keyword analyzer to the description attribute.

Add Analyzer

Select the keyword analyzer

Make sure to save your changes then publish your domain settings for your changes to take effect.

Configure Exact Match Search – Widget Settings

Next we need to configure our search widget to use our textual relevance settings.

Navigate to a widget variation and click add rule.

Add rule to a widget Variation

Click the top icon on the left to set the site context.  Add a context rule for Keyword and select the contains option.  In the input box, type a single quote mark.

Add keyword rule to the site context

Click the bottom icon on the left to configure the settings.  Click the tab for Textual Relevance and click the toggle to enable the configuration.  Notice that the description field is listed twice, once for each analyzer. From here you can enable/disable each attribute/analyzer and set its relative weight.  In this example, I’ve set the description-keyword to 3 and the name-multilocal to 1.  This will do the exact match search only on the description attribute.  You could include name-keyword analyzer to do an exact match on the name as well if that is desired.

Description keyword rule

Repeat the process to add or modify a second rule that uses the description-multilocal analyzer.

Description multilocale rule

This rule will be the fallback if the search term does not include a quote.

Rule order and fallback

Exact Match Search in Action

With this configuration in place, you can see the difference in the search results.  In this example, I’ve searched for “proxy statements”.

When you include a quote mark in the search term, you only get results that have the exact phrase “proxy statements”.  This search returns 12 results.

Exact match search with 12 results

When you do not include the quote mark in the search term, you get results that include proxy, statements and statement.  This search returns 68 results.

Relevance search with 68 results

Securing your Sitecore XM Cloud environment is critical to protecting your content, your users, and your brand. This post walks through key areas of XM Cloud security, including user management, authentication, secure coding, and best practices you can implement today to reduce your security risks.

We’ll also take a step back to look at the Sitecore Cloud Portal—the central control panel for managing user access across your Sitecore organization. Understanding both the Cloud Portal and XM Cloud’s internal security tools is essential for building a strong foundation of security.

Sitecore Cloud Portal User Management: Centralized Access Control

The Sitecore Cloud Portal is the gateway to managing user access across all Sitecore DXP tools, including XM Cloud. Proper setup here ensures that only the right people can view or change your environments and content.

Organization Roles

Each user you invite to your Sitecore organization is assigned an Organization Role, which defines their overall access level:

• Organization Owner – Full control over the organization, including user and app management.

• Organization Admin – Can manage users and assign app access, but cannot assign/remove Owners.

• Organization User – Limited access; can only use specific apps they’ve been assigned to.

Tip: Assign the “Owner” role sparingly—only to those who absolutely need full administrative control.

App Roles

Beyond organization roles, users are granted App Roles for specific products like XM Cloud. These roles determine what actions they can take inside each product:

• Admin – Full access to all features of the application.

• User – More limited, often focused on content authoring or reviewing.

Managing Access

From the Admin section of the Cloud Portal, Organization Owners or Admins can:

• Invite new team members and assign roles.

• Grant access to apps like XM Cloud and assign appropriate app-level roles.

• Review and update roles as team responsibilities shift.

• Remove access when team members leave or change roles.

Security Tips:

• Review user access regularly.

• Use the least privilege principle—only grant what’s necessary.

• Enable Multi-Factor Authentication (MFA) and integrate Single Sign-On (SSO) for extra protection.

XM Cloud User Management and Access Rights

Within XM Cloud itself, there’s another layer of user and role management that governs access to content and features.

Key Concepts

• Users: Individual accounts representing people who work in the XM Cloud instance.

• Roles: Collections of users with shared permissions.

• Domains: Logical groupings of users and roles, useful for managing access in larger organizations.

Recommendation: Don’t assign permissions directly to users—assign them to roles instead for easier management.

Access Rights

Permissions can be set at the item level for things like reading, writing, deleting, or publishing. Access rights include:

• Read

• Write

• Create

• Delete

• Administer

Each right can be set to:

• Allow

• Deny

• Inherit

Best Practices

• Follow the Role-Based Access Control (RBAC) model.

• Create custom roles to reflect your team’s structure and responsibilities.

• Audit roles and access regularly to prevent privilege creep.

• Avoid modifying default system users—create new accounts instead.

Authentication and Client Credentials

XM Cloud supports robust authentication mechanisms to control access between services, deployments, and repositories.

Managing Client Credentials

When integrating external services or deploying via CI/CD, you’ll often need to authenticate through client credentials.

• Use the Sitecore Cloud Portal to create and manage client credentials.

• Grant only the necessary scopes (permissions) to each credential.

• Rotate credentials periodically and revoke unused ones.

• Use secure secrets management tools to store client IDs and secrets outside of source code.

For Git and deployment pipelines, connect XM Cloud environments to your repository using secure tokens and limit access to specific environments or branches when possible.

Secure Coding and Data Handling

Security isn’t just about who has access—it’s also about how your code and data behave in production.

Secure Coding Practices

• Sanitize all inputs to prevent injection attacks.

• Avoid exposing sensitive information in logs or error messages.

• Use HTTPS for all external communications.

• Validate data both on the client and server sides.

• Keep dependencies up to date and monitor for vulnerabilities.

Data Privacy and Visitor Personalization

When using visitor data for personalization, be transparent and follow data privacy best practices:

• Explicitly define what data is collected and how it’s used.

• Give visitors control over their data preferences.

• Avoid storing personally identifiable information (PII) unless absolutely necessary.

Where to Go from Here

Securing your XM Cloud environment is an ongoing process that involves team coordination, regular reviews, and constant vigilance. Here’s how to get started:

• Audit your Cloud Portal roles and remove unnecessary access.

• Establish a role-based structure in XM Cloud and limit direct user permissions.

• Implement secure credential management for deployments and integrations.

• Train your developers on secure coding and privacy best practices.

The stronger your security practices, the more confidence you—and your clients—can have in your digital experience platform.

AI transforms how businesses create, maintain, and provide engaging content in Sitecore. Embedding AI, Sitecore allows developers, marketers, and IT professionals to improve workflows, enhance customer interaction, and fine-tune digital strategies. Let’s explore how AI is shaping Sitecore and what it means for businesses.

Key AI Features in Sitecore

From Content Hub to XM Cloud, products in Sitecore’s portfolio have embedded AI that provides speed and scalability to personalization. Noteworthy features include:

• AI-powered content creation: Marketers can utilize AI to write articles, rephrase language, or write content for a certain audience. This minimizes manual effort and allows teams to focus on their strategy projects.
• Personalization at Scale: AI leverages user behavior to provide scaled personalized engagement, like personalized product recommendations, or personalizing dynamic page layouts. This improves customer engagement and conversion rates remain on the rise.
• Smart Search: Based on user intents and behaviors, Sitecore delivers relevant results through AI-enabled smart search capabilities for visitors, so that they can find the information they are looking for in the blink of an eye, enriching their overall experience.
• A/B Testing: Real-time multi-armed bandit machine learning algorithms will continuously optimize the variations of content that an end user sees, showing the most efficient version of a web page or campaign.
• Augmented Analytics: AI improves the analysis of consumer data by detecting trends and patterns that support improved decision-making.

Advantages of Integrating AI with Sitecore

There are several important benefits for organizations with embedded AI in Sitecore:

• Improved Efficiency: Automating repetitive tasks such as content tagging, approval procedures, and translations allows focusing on more valuable activities.
• Enhanced Creativity: New product offerings like Sitecore Stream, brand-aware assistant, give marketers agility to work with brand assets in new ways that align creativity across brand campaigns.
• Predictive Modeling: With advanced machine learning algorithms, patterns are identified in client behaviors, which enable organizations to make data-informed predictions and improve decision-making, leading to better business outcomes.
• Improved Security: AI can identify patterns in data that suggest unexpected behavior, which could mean a security breach or fraudulent activity, enhancing website safety.

Sector-Wise Applications

Sitecore AI deployment is also being used widely across multiple verticals:

• Retail: Tailored product recommendations are based on browsing history, which helps boosting sales, and enhance the user experience.
• Media and Entertainment: Automated video content tagging simplifies media management workflows.
• Global Businesses: Businesses use AI translation programs to adapt content more quickly for a larger audience.

Challenges and Considerations

However, despite the clear benefits, integrating Sitecore with AI is not without its challenges. Organizations are forced to navigate additional challenges such as data security, implementation costs, and making sure the AI outputs maintain their brand identity. Skilled personnel are needed to manage these advanced tools effectively.

Conclusion

Sitecore is evolving into a high-performance, AI-infused platform that powers personalized digital experiences at scale. Sitecore provides businesses with the tools they need to automate tasks, encourage creativity, and derive actions from data analytics, allowing businesses to stay relevant in an ever-changing environment. In a time where upstanding customer relationships are just as important as an online approach, leveraging AI with their Sitecore development strategy can do wonders.

Sitecore Search is a robust search solution designed to streamline the indexing and retrieval of content with ease. Supporting a wide range of source types empowers developers to integrate various content repositories without breaking a sweat. In this blog, we’ll take a deep dive into the different Sitecore Search source types, complete with implementation examples, to help you hit the ground running—and maybe even have a little fun along the way! Because let’s face it, even search solutions can be exciting when you know what you’re doing. Ready? Let’s search for success!

Sitecore Search supports multiple content sources, including web crawlers, API-based sources, Sitecore Content (XM/XP), database sources, and file-based sources.

Web Crawler & Web Crawler (Advanced)

Sitecore Search web crawlers index external websites such as marketing pages, blogs, or help documentation. They can extract content, metadata, titles, and links to unify search across sources. The crawlers support pagination, respect robots.txt, and can follow links, including PDFs. They work with public-facing sites or gated content, depending on authentication support. The basic crawler is best for static HTML, while the advanced crawler adds support for dynamic content and API-based sources.

The basic web crawler is suitable for crawling simple blogs or marketing pages, extracting standard elements like title, body, and metadata, and handling basic pagination. It can also use sitemaps or simple URL filters and supports basic authentication for gated content. However, for more complex scenarios, an advanced crawler is required. It supports authenticated content using tokens or custom headers, can extract and process PDF links, and handles DOM-based or multi-template extraction. The advanced crawler also works well for indexing multilingual websites, crawling structured content like tables or schema.org metadata, and accessing dynamic or JavaScript-heavy sites by targeting API endpoints.

API Crawler

An organization has product data stored in a headless CMS or a custom e-commerce platform. Each product is available through a RESTful API endpoint using a query like:

query { 
    products {
       id
       name
       description
       price
      image {
        url
        altText
       }
   }

This query retrieves structured product data and media information (image URL and alt text), which can be mapped to Sitecore Search index fields for display in search results or personalized experiences.

The goal is to make this content searchable in Sitecore Search with structured metadata (name, description, price, categories, images).

The API crawler is ideal when data isn’t available as public HTML pages or when there’s a need for complete control over indexing. It sends GET requests to the API, parses the JSON response, and maps the data to Sitecore Search index fields. It supports pagination, token-based authentication, and custom headers, making it perfect for secure or complex integrations. You can filter, transform, or enrich data before indexing, which is especially useful for frequently updated sources like product catalogs or content managed in headless CMS platforms.

What to Keep in Mind

When implementing Sitecore Search, it’s crucial to consider factors like content freshness (no one likes outdated results), indexing frequency (because a once-a-year refresh isn’t cutting it), and data structure (keep it clean or risk a search disaster). If you’re working with JavaScript-heavy websites, be prepared—web crawlers might get overwhelmed, so some extra configuration might be required. For API-based sources, make sure you handle rate limits and authentication properly, or you’ll be stuck waiting for permission to proceed. When indexing Sitecore CMS content, remember to factor in versioning and workflow states—after all, only the published content should make it to the index. With a little attention to detail, your search results will be top-notch, and everyone will think you’re a Sitecore Search wizard!

Sitecore Search provides a range of flexible source types to meet all your indexing needs, ensuring that businesses can deliver a seamless and efficient search experience. Whether it’s website content, structured data, or document-based information, Sitecore Search has the tools to make everything searchable and accessible—like a super-powered search engine, but without the superhero cape (though we’re sure it’d look good).In my next blog, we’ll explore more Sitecore Search source types and their unique use cases. It will be a journey, and no, you won’t need a compass—just a good internet connection and maybe a cup of coffee! Stay tuned for more! For a comprehensive overview of Sitecore Search, including crawlers, extractors, and widgets, please refer to my earlier blog post: Making Sense of Sitecore Search: Crawlers, Extractors, and Widgets.