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!

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.

This post builds on our original GenStudio for Performance Marketing in 5 Minutes overview. In that post, we explored what GenStudio is, how to get started, and where it fits in the content creation process.
Since then, we’ve continued testing GenStudio and tracking its evolution. Here’s what we’ve learned—and what’s new.

Real-World Use Cases for GenStudio

GenStudio helps marketers scale content creation and personalization. Here are a few high-impact use cases:

• Reuse content from past campaigns across multiple channels
• Personalize content by product, offer, or audience segment
• Localize content for different languages and regions
• Optimize content using performance insights

These use cases make GenStudio a powerful tool for performance marketing teams.

What’s New in GenStudio

Adobe continues to enhance GenStudio with new features and integrations. Since our initial review, here are some of the most notable updates:

• Multilingual content creation in 12 languages
• Video support for LinkedIn and Meta templates
• Rich text formatting in content variants
• Starter templates to accelerate creative production
• Workfront Proof integration for streamlined reviews

You can find the full list of updates and fixes on Adobe’s release notes page.

What’s Working and What We’d Like to See

Development Considerations

GenStudio is primarily UI-based, which makes version control tricky. We recommend managing template versions outside the platform. Keeping multiple versions inside GenStudio can confuse users and clutter the workspace.

However, deleting templates can break experiences built from them. Proceed with caution.

Although rudimentary, it is possible to use the search tool to find a template and then create an experience from that template. It can be used while navigating templates, or when creating new content and prompted for a template, as in the example pictured below. 

Activation Channels Are Expanding

GenStudio now supports activation to Meta, Google Campaign Manager 360, and LinkedIn. Adobe has also announced upcoming support for:

• Microsoft Advertising
• Snap
• TikTok

Integration with Adobe Journey Optimizer (AJO) is now available as well.

Managing Multiple Brands

We’ve added several brands to our GenStudio instance, including the one behind LumaX—our shopping experience site that demonstrates Edge Delivery Services, StreamX, Adobe Commerce, and Adobe Experience Platform integrations.

Adobe has previewed a Unified Branding Service in webinars, but we’re still waiting on official documentation and guidance on how to use it across applications.

Visualizing the Experience

The infographic below shows how we’ve structured GenStudio for performance marketing. Your experience may vary depending on your configuration and rollout stage.

Click the image to enlarge the infographic.

Final Thoughts

We’re excited about GenStudio’s momentum and its growing list of features. As we continue building experiences that align with our clients’ needs, here are the things we’d love to see from Adobe in the future:

• Best practices for image generation
• Guidance on organizing assets
• Faster performance and load times

As GenStudio evolves, so does the opportunity to reimagine how we create, personalize, and activate content at scale. We’re committed to exploring what’s possible—and sharing what we learn—so our clients can stay ahead in a fast-moving digital landscape.

Meet Acquia Source

Acquia Source powered by Drupal is Acquia’s SaaS solution to streamline building, managing, and deploying websites at scale, representing a fundamental shift in how organizations approach digital experience creation. This innovative platform combines the power of Drupal with a modern component-based architecture, delivering a unique hybrid approach that bridges traditional CMS capabilities with contemporary development practices.

At its core, Acquia Source is a SaaS offering that provides Drupal functionality enhanced with a custom component architecture built on React and Tailwind CSS. Components can be created through React, Tailwind 4, and CSS, allowing developers to write CSS and React directly within the platform without need for complex dev workflows. This approach eliminates the need for custom modules or PHP code, streamlining the development process while maintaining the robust content management capabilities that Drupal is known for.

Unlike traditional Drupal implementations that require extensive backend development, Acquia Source focuses on frontend component creation and content architecture. This makes it accessible to a broader range of developers while still leveraging Drupal’s proven content management foundation. For detailed technical specifications and implementation guides, explore the comprehensive documentation and learn more about the platform on Acquia’s official pages.

Why Acquia Source is a Game-Changer

The React-based component architecture at the heart of Acquia Source offers several compelling advantages that address common pain points in digital experience development. It provides a user-friendly Experience Builder to help you create and edit pages, robust user management features to control permissions and collaboration, and a design system approach that enables teams to define and enforce style and interaction patterns across pages.

One of the most significant benefits is the demoable, out-of-the-box feature set that allows teams to showcase functionality immediately without extensive development work. Since Acquia Source operates as a SaaS solution, updates and platform management are completely offloaded from your team, eliminating the traditional burden of infrastructure maintenance, security patching, and version upgrades that typically consume resources in custom Drupal implementations.

The platform maintains Drupal’s standard content type architecture, ensuring that content creators and administrators can leverage familiar workflows and structures. This consistency reduces training requirements and maintains efficiency while introducing modern frontend capabilities.

Perhaps most importantly for development teams, Acquia Source uses React and CSS technologies that frontend developers already understand. Unlike proprietary low-code solutions that require learning platform-specific languages or architectures, developers can immediately apply their existing React and Tailwind CSS knowledge. This eliminates the typical learning curve associated with new platforms and enables faster team onboarding and development.

Changing the Playbook for Smaller companies

Acquia Source fundamentally changes the accessibility of high-end digital Drupal experiences, particularly for smaller companies and businesses that previously couldn’t justify the cost or complexity of enterprise-level implementations. The platform’s quick spin-up capability means organizations can have a sophisticated digital presence operational in weeks/months rather than months/years.

With updates handled entirely by the SaaS solution, businesses no longer need to budget for ongoing maintenance, security updates, or platform upgrades. This predictable cost model makes enterprise-level functionality accessible to organizations with limited technical resources or budget constraints.

The platform eliminates the need for complex strategy engagements or extensive architecture planning that typically precede major Drupal implementations. For many use cases, the offering can be as simple as skinning out-of-the-box components to match brand requirements, dramatically reducing both time-to-market and project complexity. Gone are the days of extensive discussions about which address module or maps integration are required for a specific implementation.

The content-type-only architecture approach allows smaller development teams to deliver sophisticated results without deep Drupal expertise. This lower barrier of entry enables smaller firms to confidently engage with top-tier Acquia partners such as Perficient, providing access to extensive libraries of industry and technology-specific experts without requiring large internal development teams. This ease of access means that businesses can leverage enterprise-grade expertise and proven methodologies regardless of their size or internal technical capabilities.

Conclusion: Your Next Learning Priority

Acquia Source represents the future of accessible, scalable digital experience development. By combining the proven content management capabilities of Drupal with modern React-based component architecture, it offers a compelling solution for organizations seeking to deliver sophisticated digital experiences without the traditional complexity and resource requirements.

For marketing professionals, Acquia Source offers unprecedented speed-to-market, creative flexibility and ability to leverage existing frontend resources. For architects and developers, it provides a platform that leverages existing skills while eliminating infrastructure concerns and reducing project complexity.

The platform’s unique position in the market, providing advanced Drupal capabilities through a SaaS model with familiar development technologies makes it an invaluable tool for any developer or agency to have in their toolbox.

Start your Acquia Source journey today by exploring the comprehensive documentation and registering for the Partner Master Class: Introducing Acquia Source powered by Drupal to gain hands-on experience with this transformative platform.

Intro

In this post I’d like to share a workflow “attacher” implementation I built on a recent Sitecore XM Cloud project. The solution attaches workflows to new items based on a configurable list of template and path rules. It was fun to build and ended up involving a couple Sitecore development mechanisms I hadn’t used in a while:

• The venerable Sitecore configuration factory to declaratively define runtime objects
• The newer pipeline processor invoked when items are created from a template: addFromTemplate

This implementation provided our client with a semi-extensible way of attaching workflows to items without writing any additional code themselves. “But, Nick, Sitecore already supports attaching workflows to items, why write any custom code to do this?” Great question .

The Problem

The go-to method of attaching workflows to new items in Sitecore is to set the workflow fields on Standard Values for the template(s) in question. For example, on a Page template in a headless site called Contoso (/sitecore/templates/Project/Contoso/Page/__Standard Values). This is documented in the Accelerate Cookbook for XM Cloud here. Each time a new page is created using that template, the workflow is associated to (and is usually started on) the new page.

Setting workflow Standard Values fields on site-specific or otherwise custom templates is one thing, but what about on out-of-the-box (OOTB) templates like media templates? On this particular project, there was a requirement to attach a custom workflow to any new versioned media items.

I didn’t want to edit Standard Values on any of the media templates that ship with Sitecore. However unlikely, those templates could change in a future Sitecore version. Also, worrying about configuring Sitecore to treat any new, custom media templates in the same way as the OOTB media templates just felt like a bridge too far.

I thought it would be better to “listen” for new media items being created and then check to see if a workflow should be attached to the new item or not. And, ideally, it would be configurable and would allow the client’s technical resources to enumerate one or more workflow “attachments,” each independently configurable to point to a specific workflow, one or more templates, and one or more paths.

The Solution

Disclaimer: Okay, real talk for a second. Before I describe the solution, broadly speaking, developers should try to avoid customizing the XM Cloud content management (CM) instance altogether. This is briefly mentioned in the Accelerate Cookbook for XM Cloud here. The less custom code deployed to the CM the better; that means fewer points of failure, better performance, more expedient support ticket resolution, etc. As Robert Galanakis once wrote, “The fastest code is the code which does not run. The code easiest to maintain is the code that was never written.”

With that out of the way, in the real world of enterprise XM Cloud solutions, you may find yourself building customizations. In the case of this project, I didn’t want to commit to the added overhead and complexity of building out custom media templates, wiring them up in Sitecore, etc., so I instead built a configurable workflow attachment mechanism to allow technical resources to enumerate which workflows should start on which items based on the item’s template and some path filters.

addFromTemplate Pipeline Processor

Assuming it’s enabled and not otherwise bypassed, the addFromTemplate pipeline processor is invoked when an item is created using a template, regardless of where or how the item was created. For example:

• When a new page is created in the Content Editor
• When a new data source item is created using Sitecore PowerShell Extensions
• When an item is created as the result of a branch template
• When a new media item is uploaded to the media library
• When several media items are uploaded to the media library at the same time
• …etc.

In years past, the item:added event handler may have been used in similar situations; however, it isn’t as robust and doesn’t fire as consistently given all the different ways an item can be created in Sitecore.

To implement an addFromTemplate pipeline processor, developers implement a class inheriting from AddFromTemplateProcessor (via Sitecore.Pipelines.ItemProvider.AddFromTemplate). Here’s the implementation for the workflow attacher:

using Contoso.Platform.Extensions;
using Sitecore.Pipelines.ItemProvider.AddFromTemplate;
...

namespace Contoso.Platform.Workflow
{
    public class AddFromTemplateGenericWorkflowAttacher : AddFromTemplateProcessor
    {
        private List<WorkflowAttachment> WorkflowAttachments = new List<WorkflowAttachment>();

        public void AddWorkflowAttachment(XmlNode node)
        {
            var attachment = new WorkflowAttachment(node);
            if (attachment != null)
            {
                WorkflowAttachments.Add(attachment);
            }
        }

        public override void Process(AddFromTemplateArgs args)
        {
            try
            {
                Assert.ArgumentNotNull(args, nameof(args));

                if (args.Aborted || args.Destination.Database.Name != "master")
                {
                    return;
                }

                // default to previously resolved item, if available
                Item newItem = args.ProcessorItem?.InnerItem;

                // use previously resolved item, if available
                if (newItem == null)
                {
                    try
                    {
                        Assert.IsNotNull(args.FallbackProvider, "Fallback provider is null");

                        // use the "base case" (the default implementation) to create the item
                        newItem = args.FallbackProvider.AddFromTemplate(args.ItemName, args.TemplateId, args.Destination, args.NewId);
                        if (newItem == null)
                        {
                            return;
                        }

                        // set the newly created item as the result and downstream processor item
                        args.ProcessorItem = args.Result = newItem;
                    }
                    catch (Exception ex)
                    {
                        Log.Error($"{nameof(AddFromTemplateGenericWorkflowAttacher)} failed. Removing partially created item, if it exists", ex, this);

                        var item = args.Destination.Database.GetItem(args.NewId);
                        item?.Delete();

                        throw;
                    }
                }

                // iterate through the configured workflow attachments
                foreach (var workflowAttachment in WorkflowAttachments)
                {
                    if (workflowAttachment.ShouldAttachToItem(newItem))
                    {
                        AttachAndStartWorkflow(newItem, workflowAttachment.WorkflowId);
                        // an item can only be in one workflow at a time
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error($"There was a processing error in {nameof(AddFromTemplateGenericWorkflowAttacher)}.", ex, this);
            }
        }

        private void AttachAndStartWorkflow(Item item, string workflowId)
        {
            item.Editing.BeginEdit();

            // set default workflow
            item.Fields[Sitecore.FieldIDs.DefaultWorkflow].Value = workflowId;
            // set workflow
            item.Fields[Sitecore.FieldIDs.Workflow].Value = workflowId;
            // start workflow
            var workflow = item.Database.WorkflowProvider.GetWorkflow(workflowId);
            workflow.Start(item);

            item.Editing.EndEdit();
        }
    }
}

Notes:

• The WorkflowAttachments member variable stores the list of workflow definitions (defined in configuration).
• The AddWorkflowAttachment() method is invoked by the Sitecore configuration factory to add items to the WorkflowAttachments list.
• Assuming the creation of the new item wasn’t aborted, the destination database is master, and the new item is not null, the processor iterates over the list of workflow attachments and, if the ShouldAttachToItem() extension method returns true, the AttachAndStartWorkflow() method is called.
• The AttachAndStartWorkflow() method associates the workflow to the new item and starts the workflow on the item.
• Only the first matching workflow attachment is considered—an item can only be in one (1) workflow at a time.

The implementation of the ShouldAttachToItem() extension method is as follows:

...

namespace Contoso.Platform
{
    public static class Extensions
    {
        ...
        public static bool ShouldAttachToItem(this WorkflowAttachment workflowAttachment, Item item)
        {
            if (item == null)
                return false;

            // check exclusion filters
            if (workflowAttachment.PathExclusionFilters.Any(exclusionFilter => item.Paths.FullPath.IndexOf(exclusionFilter, StringComparison.OrdinalIgnoreCase) > -1))
                return false;

            // check inclusion filters
            if (workflowAttachment.PathFilters.Any() &&
                !workflowAttachment.PathFilters.Any(includeFilter => item.Paths.FullPath.StartsWith(includeFilter, StringComparison.OrdinalIgnoreCase)))
                return false;

            var newItemTemplate = TemplateManager.GetTemplate(item);

            // check for template match or template inheritance
            return workflowAttachment.TemplateIds.Any(id => ID.TryParse(id, out ID templateId)
                && (templateId.Equals(item.TemplateID)
                    || newItemTemplate.InheritsFrom(templateId)));
        }
    }
    ...
}

Notes:

• This extension method determines if the workflow should be attached to the new item or not based on the criteria in the workflow attachment object.
• The method evaluates the path exclusion filters, path inclusion filters, and template ID matching or inheritance (in that order) to determine if the workflow should be attached to the item.

Here’s the WorkflowAttachment POCO that defines the workflow attachment object and facilitates the Sitecore configuration factory’s initialization of objects:

using Sitecore.Diagnostics;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml;

namespace Contoso.Platform.Workflow
{
    public class WorkflowAttachment
    {
        public string WorkflowId { get; set; }

        public List<string> TemplateIds { get; set; }

        public List<string> PathFilters { get; set; }

        public List<string> PathExclusionFilters { get; set; }

        public WorkflowAttachment(XmlNode workflowAttachmentNode)
        {
            TemplateIds = new List<string>();
            PathFilters = new List<string>();
            PathExclusionFilters = new List<string>();

            if (workflowAttachmentNode == null)
                throw new ArgumentNullException(nameof(workflowAttachmentNode),
                    $"The workflow attachment configuration node is null; unable to create {nameof(WorkflowAttachment)} object.");

            // parse nodes
            foreach (XmlNode childNode in workflowAttachmentNode.ChildNodes)
            {
                if (childNode.NodeType != XmlNodeType.Comment)
                    ParseNode(childNode);
            }

            // validate
            Assert.IsFalse(string.IsNullOrWhiteSpace(WorkflowId), $"{nameof(WorkflowId)} must not be null or whitespace.");
            Assert.IsTrue(TemplateIds.Any(), "The workflow attachment must enumerate at least one (1) template ID.");
        }

        private void ParseNode(XmlNode node)
        {
            switch (node.LocalName)
            {
                case "workflowId":
                    WorkflowId = node.InnerText;
                    break;
                case "templateIds":
                    foreach (XmlNode childNode in node.ChildNodes)
                    {
                        if (childNode.NodeType != XmlNodeType.Comment)
                            TemplateIds.Add(childNode.InnerText);
                    }
                    break;
                case "pathFilters":
                    foreach (XmlNode childNode in node.ChildNodes)
                    {
                        if (childNode.NodeType != XmlNodeType.Comment)
                            PathFilters.Add(childNode.InnerText);
                    }
                    break;
                case "pathExclusionFilters":
                    foreach (XmlNode childNode in node.ChildNodes)
                    {
                        if (childNode.NodeType != XmlNodeType.Comment)
                            PathExclusionFilters.Add(childNode.InnerText);
                    }
                    break;
                default:
                    break;
            }
        }
    }
}

Configuration

The following patch configuration file is defined to A. wire-up the addFromTemplate pipeline processor and B. describe the various workflow attachments. In the sample file below, for brevity, there’s only one (1) attachment defined, but multiple attachments are supported.

<configuration>
  <sitecore>
  ...
  <pipelines>
    <group name="itemProvider" groupName="itemProvider">
      <pipelines>
        <addFromTemplate>
          <processor
            type="Contoso.Platform.Workflow.AddFromTemplateGenericWorkflowAttacher, Contoso.Platform"
            mode="on">
            <!-- Contoso Media Workflow attachment for versioned media items and media folders -->
            <workflowAttachmentDefinition hint="raw:AddWorkflowAttachment">
              <workflowAttachment>
                <!-- /sitecore/system/Workflows/Contoso Media Workflow -->
                <workflowId>{88839366-409A-4E57-86A4-167150ED5559}</workflowId>
                <templateIds>
                  <!-- /sitecore/templates/System/Media/Versioned/File -->
                  <templateId>{611933AC-CE0C-4DDC-9683-F830232DB150}</templateId>
                  <!-- /sitecore/templates/System/Media/Media folder -->
                  <templateId>{FE5DD826-48C6-436D-B87A-7C4210C7413B}</templateId>
                </templateIds>
                <pathFilters>
                  <!-- Contoso Media Library Folder -->
                  <pathFilter>/sitecore/media library/Project/Contoso</pathFilter>
                </pathFilters>
                <pathExclusionFilters>
                  <pathExclusionFilter>/sitecore/media library/System</pathExclusionFilter>
                  <pathExclusionFilter>/Sitemap</pathExclusionFilter>
                  <pathExclusionFilter>/Sitemaps</pathExclusionFilter>
                  <pathExclusionFilter>/System</pathExclusionFilter>
                  <pathExclusionFilter>/_System</pathExclusionFilter>
                </pathExclusionFilters>
              </workflowAttachment>
            </workflowAttachmentDefinition>
            ...
          </processor>
        </addFromTemplate>
      </pipelines>
    </group>
  </pipelines>
  ...
  </sitecore>
</configuration>

Notes:

• N number of <workflowAttachmentDefinition> elements can be defined.
• Only one (1) <workflowId> should be defined per attachment.
• The IDs listed within the <templateIds> element are the templates the new item must either be based on or inherit from.
• The <pathFilters> element enumerates the paths under which the workflow attachment should apply. If the new item’s path is outside of any of the paths listed, then the workflow is not attached. This element can be omitted to forgo the path inclusion check.
• The <pathExclusionFilters> element enumerates the paths under which the workflow attachment should not apply. If the new item’s path contains any of these paths, then the workflow is not attached. This element can be omitted to forgo the path exclusion check. This filtering is useful to ignore new items under certain paths, e.g., under the Sitemap or Thumbnails media folders, both of which are media folders controlled by Sitecore.

Closing Thoughts

While certainly not a one-size-fits-all solution, this approach was a good fit for this particular project considering the requirements and a general reticence for modifying Standard Values on OOTB Sitecore templates. Here are some pros and cons for this solution:

Pros

• Provides a semi-extensible, configuration-based way to start workflows on new items.
• Adding, updating, or removing a workflow attachment requires a configuration change but not code change.
• Allows for a template ID match or inheritance for more flexibility.
• Allows for path inclusion and exclusion filtering for more granular control over where in the content tree the workflow attachment should (or should not) apply.

Cons

• Deploying custom server-side code to the XM Cloud CM instance isn’t great.
• Arguably, creating custom templates inheriting from the OOTB templates in order to attach the workflows was the “more correct” play.
• A deployment to change a configuration file could still require a code deployment—many (most?) pipelines don’t separate the two. If configuration changes are deployed, then so is the code (which, of course, necessitates additional testing).

Takeaways:

• If you’re building an XM Cloud solution, do your best to avoid (or at least minimize) customizations to the CM.
• If you need to attach workflows to specific project templates or custom templates, do so via Standard Values (and serialize the changes)—don’t bother with custom C# code.
• If, for whatever reason, you need to resort to a custom solution, consider this one (or something like it).
• Of course, this solution can be improved; to list a few possible improvements:
  • Pushing the configuration files into Sitecore to allow content authors to manage workflow attachment definitions. This would require a permissions pass and some governance to help prevent abuse and/or misconfigurations.
  • Add support to conditionally start the workflow; at present, the workflow always starts on new items.
  • Add logic to protect against workflow clobbering if, for whatever reason, the new item already has a workflow attached to it.
  • Improve path matching when applying the path inclusion and exclusion filters.
  • Logging improvements.

Thanks for the read!

Resources

• https://sitecore.stackexchange.com/questions/523/execute-custom-logic-whenever-an-item-is-added-from-a-particular-branch-template
• https://sitecore-community.github.io/docs/documentation/Sitecore%20Fundamentals/Sitecore%20Configuration%20Factory
• https://developers.sitecore.com/learn/accelerate/xm-cloud

This blog post will discuss MultiSite validation for either ContentArea or LinkItemCollection, which are both capable of storing multiple items. Although we can use the custom MaxItem attribute to validate the ContentArea or LinkItemCollection, the problem arises when the same property is used for multiple sites with different validation limits.

In a recent project, we were tasked with migrating multiple websites into a single platform using Optimizely. These sites shared common ContentTypes wherever applicable, though their behavior varied slightly depending on the site.

One of the main challenges involved a ContentType used as the StartPage with the same properties across different sites. While the structure remained the same, the validation rules for its properties differed based on the specific site requirements. A common issue was enforcing a maximum item validation limit on a property like a ContentArea, where each site had a different limit—for example, Site A allowed a maximum of 3 items, while Sites B and C allowed 4 and 5 items, respectively.

To solve this multisite validation scenario, we implemented a custom validation attribute that dynamically validated the maximum item limit based on the current site context.

Below are the steps we followed to achieve this.

• Make a MaxItemsBySitesAttribute custom validation attribute class and add an AttributeUsage attribute with AllowMultiple = true.
• Then inherit from ValidationAttribute as a base class. This class is used to provide server-side validation rules on content properties for Block, Page, or Media content types.

    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
    public class MaxItemsBySitesAttribute : ValidationAttribute
    {
        private readonly string[] _siteName;
        private int _max;

        public MaxItemsBySitesAttribute(int max, params string[] siteName)
        {
            _max = max;
            _siteName = siteName;
        }
        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            var siteSpecificLimit = GetSiteSpecificMaxLimitByFieldName(validationContext.MemberName, validationContext?.ObjectType?.BaseType);
            string errorMsg = $"{validationContext.DisplayName}, exceeds the maximum limit of {siteSpecificLimit} items for site {SiteDefinition.Current.Name}";

            if (value is ContentArea contentArea)
            {
                if (contentArea.Count > siteSpecificLimit)
                {
                    return new ValidationResult(errorMsg);
                }
            }
            else if (value is LinkItemCollection linkItems)
            {
                if (linkItems.Count > siteSpecificLimit)
                {
                    return new ValidationResult(errorMsg);
                }
            }

            return ValidationResult.Success;
        }

        private int GetSiteSpecificMaxLimitByFieldName(string fieldName, Type type)
        {
            var propertyInfo = type.GetProperty(fieldName);
            if (propertyInfo != null)
            {
                var attributes = propertyInfo.GetCustomAttributes<MaxItemsBySitesAttribute>()?.ToList();
                var siteMaxLimit = attributes.FirstOrDefault(x => x._siteName != null && 
                                                             x._siteName.Any(site => site == SiteDefinition.Current.Name));

                return siteMaxLimit == null ? 0 : siteMaxLimit._max;
            }
            return 0;
        }
    }

• • The function GetSiteSpecificMaxLimitByFieldName() in the above code played an important role in this class to retrieve decorated attribute(s) [MaxItemsBySites(2, “AlloyBlog”)] and [MaxItemsBySites(3, “AlloyDemo”, “AlloyEvents”)] with specified item limit counts and site names.

• Then, decorate the [MaxItemsBySites] custom attribute(s) on the ContentArea or LinkItemCollection property by adding the maximum item limit and site(s) name as given below.

public class StartPage : SitePageData
{
    [Display(
        GroupName = SystemTabNames.Content,
        Order = 320)]
    [CultureSpecific]
    [MaxItemsBySites(2, "AlloyBlog")]
    [MaxItemsBySites(3, "AlloyDemo", "AlloyEvents")]
    public virtual ContentArea MainContentArea { get; set; }
}

• The attribute will receive a trigger and verify the maximum item limit and site name against the site that is currently running and display an error message below if validation matches.

By implementing site-specific maximum item validation in your Optimizely CMS multisite, content authors can ensure content consistency, enhance user experience, and maintain precise control over content areas and link collections across diverse properties in different sites.

In case you want other validation by site-specific, you can use the same approach by changing the code accordingly.

In today’s digital-first world, brand consistency is more than a visual guideline, it’s a strategic asset. As teams scale and content demands grow, having a centralized Brand Kit becomes essential. If you’re using Sitecore Stream, building a Brand Kit is not just useful, it’s transformational.

In my previous post, I tried to explore Sitecore Stream, highlighting how it reimagines modern marketing by bringing together copilots, agentic AI, and real-time brand intelligence to supercharge content operations. We explored how Stream doesn’t just assist it acts with purpose, context, and alignment to your brand.

Now, we take a deeper dive into one of the most foundational elements that makes that possible: Brand Kit.

In this post, we’ll cover:

• What a Brand Kit is inside Stream, and why it matters

• How to build one – from brand documents to structured sections

• How AI copilots use it to drive consistent, on-brand content creation

Let’s get into how your brand knowledge can become your brand’s superpower.

What Is a Brand Kit?

A Brand Kit is a centralized collection of brand-defining assets, guidelines, tone, messaging rules.

Brand kit sections represent a subset of your brand knowledge.
It includes information about your brands like:

• Logo files and usage rules
• Typography and color palettes
• Brand voice and tone guidelines
• Brand specific imagery or templates
• Do’s and Don’ts of brand usage
• Compliance or legal notes

Think of it as your brand’s source of truth, accessible by all stakeholders – designers, marketers, writers, developers, and AI assistants.

Why Stream Needs a Brand Kit

Stream is a platform where content flows – from ideas to execution. Without a Brand Kit:

• Writers may use inconsistent tone or terminology as per their knowledge or considerations about brand.
• Designers may reinvent the wheel with each new visual.
• Copilots might generate off-brand content.
• Cross-functional teams lose time clarifying brand basics.

With a Brand Kit in place, Stream becomes smarter, faster, and more aligned with your organization’s identity.

How a Brand Kit Helps the Organization

Here’s how Stream and your Brand Kit work together to elevate content workflows:

•  Faster onboarding: New team members instantly understand brand expectations.
•  Accurate content creation: Content writers, designers, and strategists reference guidelines directly from the platform.
•  AI-assisted content stays on-brand: Stream uses your brand data to personalize AI responses for content creation and editing.
•  Content reuse and updates become seamless with analysis: Brand messaging is consistent across landing pages, emails, and campaigns. You can also perform A/B testing with brandkit generated content vs manually added content.

Now that we understand what a Brand Kit is and why it’s essential, let’s walk through how to create one effectively within Sitecore Stream.

Uploading Brand Documents = Creating Brand Knowledge

To create a Brand Kit, you begin by uploading and organizing your brand data this includes documents, guidelines, assets, and other foundational materials that define your brand identity.

Below screenshot displays the screen of uploaded brand document, button to process the document and an option to upload another document.

In Stream, when you upload brand-specific documents, they don’t just sit there. The process:

• Analyses the data
• Transforms them into AI-usable data by Creating brand knowledge
• Makes this knowledge accessible across brainstorming, content creation, and AI prompts

In short, Here’s how the process works:

• Create a Brand Kit – Start with a blank template containing key sections like Brand Context, Tone of Voice, and Global Goals.
• Upload Brand Documents – Add materials like brand books, visual and style guides to serve as the source of your brand knowledge.
• Process Content – Click Process changes to begin ingestion. Stream analyzes the documents, breaks them into knowledge chunks, and stores them.
• Auto-Fill Sections – Stream uses built-in AI prompts to populate each section with relevant content from your documents.

Brand Kit Sections: Structured for Versatility

Once your Brand Kit is created and the uploaded documents are processed, Stream automatically generates key sections. Each section serves a specific purpose and is built from well-structured content extracted from your brand documents. These are essentially organized chunks of brand knowledge, formatted for easy use across your content workflows. Default sections that gets created are as follows:

• Global Goals – Your brand’s core mission and values.
• Brand Context – Purpose, positioning, and brand values.
• Dos and Don’ts – Content rules to stay on-brand.
• Tone of Voice – Defines your brand’s personality.
• Checklist – Quick reference for brand alignment.
• Grammar Guidelines – Writing style and tone rules.
• Visual Guidelines – Imagery, icons, and layout specs.
• Image Style – Color, emotion, and visual feel.

Each section holds detailed, structured brand information that can be updated manually or enriched using your existing brand knowledge. If you prefer to control the content manually and prevent it from being overwritten during document processing, you can mark the section as Non-AI Editable.

Stream allows you to add new subsections or customize existing ones to adapt to your evolving brand needs. For example, you might add a “Localization Rules” section when expanding to global markets, or a “Crisis Communication” section to support PR strategies.

When creating a new subsection, you’ll provide a name and an intent a background prompt that guides the AI to extract relevant information from your uploaded brand documents to populate the section accurately.

Below screenshot of sections created after brand document process and subsections for example:

AI + Brand Kit = Smarter Content, Automatically

Now we have created brand kit, lets see how AI in Stream uses your Brand Kit to:

Suggest on-brand headlines or social posts

• Flag content that strays from brand guidelines
• Assist in repurposing older content using updated brand tone

It’s like having a brand-savvy assistant embedded in your workflow.

Brand assist – in Sitecore Stream

Once you have Brand Kit ready, you can use the Brand Assistant to generate and manage content aligned with your brand using simple prompts.

Key uses:

• Ask brand-related questions
• Access brand guidelines
• Generate on-brand content
• Draft briefs and long-form content
• Explore ideas and marketing insights

It uses agentic AI, with specialized agents that ensure every output reflects your brand accurately.

When a user enters a prompt in the Brand Assistant, whether it’s a question or an instruction the copilots automatically includes information from the Brand Context section of the Brand Kit. It then evaluates whether this context alone is enough to generate a response. If it is, a direct reply is provided. If not, specialized AI agents are activated to gather and organize additional information.

These include a Search Agent (to pull data from brand knowledge or the web), a Brief Agent (for campaign or creative brief requests), and a Summary Agent (to condense information into a clear, relevant response).

I clicked on Brand Assistant tab, selected my Brand Kit, asked a question, and the response I got was spot on! It perfectly aligned with the brand documents I had uploaded and even suggested target consumer based on that information. Super impressed with how well it worked!

Now it’s time to see how the Brand Kit helps me generate content on XM Cloud or Experience Platform. To do that, connect XM Cloud website with Sitecore Stream so the copilots can access the Brand Kit.

I simply went to Site Settings, found the Stream section, selected my Stream instance and that’s it. I was all set to use brandkit.

Now, when I open the page editor and click on Optimize, I see an additional option with my Brand Kit name. Once selected, I can either draft new text or optimize existing content.

The copilot leverages the Brand Kit sections to generate content that’s consistent, aligned with our brand voice, and ready to use.

For example, I asked the brand kit to suggest campaign content ideas and it provided exactly the kind of guidance I needed.

Conclusion

Building and maintaining a Brand Kit in Stream isn’t just about visual consistency, it’s about scaling brand intelligence across the entire content lifecycle. When your Brand Kit is connected to the tools where work happens, everyone from AI to human collaborators works with the same understanding of what your brand stands for.

In a world that’s moving at lightning speed, customers expect brands to keep up — to understand them instantly, respond to their behavior in real-time, and offer relevant, helpful experiences wherever they are. This is where Artificial Intelligence (AI) has become not just useful, but absolutely essential.

The Growing Power of AI in Today’s World

AI is revolutionizing how businesses operate and how brands engage with customers. What started as automation is now intelligent orchestration:

• Recommending the right product at the right time
• Automatically generating content in your brand voice
• Detecting patterns in real-time behavior
• Personalizing experiences across every channel

From e-commerce to healthcare, entertainment to education, AI is making every industry smarter, faster, and more responsive. And customer expectations are rising accordingly.

Why Sitecore Has Embraced AI

As a leader in digital experience platforms, Sitecore understands that personalization, content delivery, and customer journey orchestration can’t rely on manual processes.

That’s why Sitecore has integrated AI deeply into its product ecosystem — not just to enhance content workflows, but to transform how real-time experiences are built and delivered.

At the heart of this transformation is Sitecore Stream.

Introducing Sitecore Stream

Sitecore Stream introduces AI capabilities to Sitecore products, specifically tailored for marketers. It empowers smarter, faster end-to-end content creation and distribution at scale, unlocking remarkable efficiency gains. Featuring brand-aware AI, intelligent copilots, autonomous agents, and streamlined agentic workflows, Sitecore Stream transforms marketing effectiveness by helping you speed up time-to-market, lower costs, and deliver compelling, consistent digital experiences across all channels.

But Sitecore Stream doesn’t just work fast — it works intelligently and brand-safely.

Sitecore Stream automates all tasks and deliverables in a marketing workflow, utilizing AI to make them faster, easier, and more consistent. Through copilots, agents, content ideation and creation, and then optimizing the customer experience.

Stream is built on the Microsoft Azure OpenAI Service, utilizing advanced large language model (LLM) technology to help teams of all sizes ideate, create, and refine on-brand content more strategically and securely.

What is an LLM?

A large language model (LLM) is a type of machine learning model designed for natural language processing tasks such as language generation. LLMs are language models with many parameters and are trained with self-supervised learning on a vast amount of text.

Large Language Models (LLMs) are a cornerstone of generative AI, powering a wide array of natural language processing tasks, including:

• Searching, translating, and summarizing text
• Answering questions with contextual understanding
• Creating new content—ranging from written text and images to music and software code

What truly sets LLMs apart is their ability to synthesize information, analyze complex data, and identify patterns and trends. This enables them to go beyond simple text generation and adapt seamlessly to diverse, specialized use cases across industries

Core Concepts & Capabilities of Sitecore Stream

Sitecore Stream transforms your marketing stack by combining:

• Brand intelligence
• AI automation
• Real-time decisioning

It’s designed to help marketers do more, faster, with less manual effort—while maintaining creative control and brand integrity. Let’s look at how Sitecore Stream makes it possible with the following capabilities:

1. Brand-Aware AI

Unlike generic AI tools, Stream uses RAG to anchor every response in the organization’s brand knowledge.

Retrieval-augmented generation (RAG) grounds AI outputs by pulling brand-specific information directly from documents uploaded by the organization. This ensures that content generation is informed by accurate, contextual brand knowledge.

Brand-aware AI is an advanced capability designed to maintain brand consistency across all Sitecore products. It leverages large language models (LLMs) and retrieves relevant information from brand resources to ensure alignment with the brand’s identity.

When brand documents are uploaded—detailing brand values, messaging, tone, visual identity, and the intended customer experience—brand knowledge is created through a process known as brand ingestion. This process organizes and optimizes the uploaded information, making it readily accessible to AI copilots across the platform.

As a result, AI-powered tools within Sitecore Stream consistently generate or suggest content that reflects the brand’s voice, tone, and guidelines. This enables marketers to scale content creation confidently, knowing all output remains true to the brand.

2. Copilots and Agents

Stream introduces AI copilots that assist marketers in real-time, offering intelligent suggestions for content, layout, targeting, and workflows. Agents go further, autonomously executing tasks like campaign personalization, journey orchestration, or data segmentation.

Copilots provide intelligent guidance to support strategic decisions, while agents handle routine actions autonomously, freeing marketers to focus on high-value strategy and creative execution.

Both copilots and agents understand natural language and predefined prompts, seamlessly assisting throughout the content creation process and minimizing repetitive work. Marketers can effortlessly request content drafts, campaign ideas, or personalized experiences, all with simple, intuitive commands.

Fully integrated into Sitecore products, these tools deliver chat-based interactions, one-click workflows, and autonomous operations, making marketing smarter, faster, and more efficient.

Sitecore Stream currently offers 3 copilots

• Brand Copilot – Helps marketers create content that matches the brand using tools for brand-aware chat, idea generation, and content briefs.
• Content Copilot – Supports content tasks like writing, refining, translating, generating content with AI in Experience Platform, and optimizing/personalizing content in Sitecore.
• Experience Copilot – Improves search with features like visual search in Content Hub and Q&A generation in Sitecore Search.

3. Agentic Workflows

What is Agentic AI?

Agentic AI refers to artificial intelligence systems that can act autonomously, pursue goals, and make decisions proactively, almost like an “agent” with a mission.

In simple terms:

Agentic AI is AI that doesn’t just respond to commands—it plans, decides, and takes initiative to achieve a goal on its own. AI that doesn’t just assist—it acts.

Stream enables agentic workflows, where AI agents execute actions (e.g., publish content, trigger campaigns) based on real-time customer behavior or campaign goals.

Successful project management starts with a clear, organized plan that prioritizes tasks and involves the right team members at the right time. By setting defined goals, monitoring progress, and fostering collaboration, teams can ensure projects stay aligned and deliver desired outcomes.

Sitecore Stream’s orchestration capability takes project management to the next level by integrating AI-driven automation tailored for marketing teams. Whether managing campaigns, product launches, or digital advertising strategies, this feature helps coordinate efforts seamlessly across teams and Sitecore products.

By introducing early-stage AI agents, orchestration supports smarter task execution and informed decision-making. This paves the way for advanced agentic workflows within Sitecore, where AI systems can autonomously drive actions, make decisions, and dynamically respond to evolving project demands.

Conclusion

AI is no longer a future investment — it’s a present necessity. Customers demand relevance, speed, and brand coherence. Sitecore Stream is Sitecore’s answer to that demand: A real-time, AI-powered platform that combines behavioral insight, brand knowledge, and automation to help brands engage customers intelligently and instantly.

This is the future of digital experience. And with Sitecore Stream, it’s already here.

Adobe is offering marketers the opportunity to experience the power of Adobe GenStudio for Performance Marketing firsthand via a product sandbox.

This interactive space will allow users to see the product in action and is designed to simulate the GenStudio for Performance Marketing workflow.

Luckily for you, Perficient is part of a select group of Adobe consulting partners with access to a fully functional sandbox. We’ve learned a few things since using the app that you can benefit from as you experiment with this new product.

In the following blog, our Adobe experts Ross Monaghan, Principal, and Raf Winterpacht, Director, share their initial impressions of GenStudio for Performance Marketing, tips and tricks, and some pitfalls to avoid when using the product for the first time.

Initial Impressions of GenStudio for Performance Marketing

When marketers first dive into Adobe GenStudio for Performance Marketing, they can expect a mix of familiarity and growing pains. Raf found the platform intuitive, noting, “It feels like Adobe. So, if you’ve worked with some of the other products like Adobe Experience Platform or AEM Assets, it’ll feel familiar to you. There wasn’t a huge learning curve when I started using it.”

From Ross’s perspective, he shared that the app initially felt early in its development. He explained, “When we first gained access to our sandbox, there weren’t a lot of channels where we could activate our assets. For example, Meta wasn’t even an option yet. So, you could create an asset, but you had no place to activate it. Everything was labeled as coming soon.”

However, he acknowledged that the platform has since evolved, with users now having access to Meta and Google Campaign Manager 360, while Microsoft Advertising, Snap, and TikTok are listed as coming soon.

Powerful Key Features

When using the application for the first time, marketers can expect a powerful tool that significantly enhances the ability to personalize and scale content creation while maintaining brand integrity.

Ross emphasized the importance of personalization at scale, noting that GenStudio allows marketers to quickly create, resize, and reuse assets to produce numerous variations that can be leveraged across various channels and campaigns. He said, “It’s practically impossible to create all the asset variations you need without something like GenStudio for Performance Marketing. You could be looking at hundreds of thousands of asset variations for just a single campaign across 25 countries and several languages.”

Raf added that the ability to rapidly generate high-quality, on-brand content is another powerful feature. One of the first things you do within GenStudio is set up your brand and provide guidelines for brand voice, imagery, logos, colors, and channel usage. Raf said, “Doing this allows marketers to use the application’s generative AI models to create high-quality content that not only adheres to your brand guidelines but also allows for rapid generation of personalized content variations that can be leveraged in various channels and campaigns.”

GenStudio for Performance Marketing Tips and Tricks

To maximize the potential of Adobe GenStudio for Performance Marketing, our experts recommend focusing on two key areas: brand completeness and prompt engineering.

Raf suggested thoroughly completing the brand section in GenStudio, as well as including as much information about your products and personas. This may take some time and effort, but doing so will ensure a better asset creation experience in the app.

He said, “We had to ask Adobe what the best, most efficient way to upload our brand guidelines was, and we were told to use a PDF. Our brand guidelines live on a SharePoint site, so we had to do some trial and error to get our brand content into a PDF that lists out all the different guidelines as much as possible. From there, the app does a good job of picking up those details from the PDF. You could do this manually if you needed to, though.”

Ross called attention to prompt engineering when using generative AI to create assets. He said, “Prompt engineering is critical when generating content in GenStudio. We found it difficult at first to figure out what the best prompts were to get the desired assets. Unfortunately, prompting is an iterative process and takes a bit of trial and error.”

Hopefully, Adobe Experience League will host a list of prompts marketers can use as a starting point one day, but until then, you can take a look at Adobe’s user guide to writing effective prompts.

Common Pitfalls to Avoid When Using GenStudio for the First Time

As with any powerful tool, success with Adobe GenStudio for Performance Marketing depends on understanding its limitations and setting it up thoughtfully from the start. Both Ross and Raf shared that while GenStudio can accelerate content creation, it’s not a replacement for human oversight.

“Users should think of it as a highly efficient way to get dynamic content to review,” Ross said. “Users still need to be the editor and verify that the content is still on brand. I worry that people want these tools to do the entire job.”

He also cautioned against underestimating the need for UI engineering. “I think another pitfall that users should avoid is thinking that they don’t need UI engineering. That is something that you definitely need to set up your templates appropriately,” he said, noting that it took significant back-and-forth with Adobe to get templates just right.

Raf echoed the importance of thoughtful setup, particularly around permissions and workflows. “You’re going to need to have certain permissions and users and groups set up in there ahead of time,” he said. “There’s a little bit of upfront work and configurations and things that have to be done before you can actually get in there and really start using the tool in a good cadence.”

Making GenStudio a Powerful Tool in Your Marketing Toolbox

Whether you’re just beginning to explore GenStudio or are already experimenting in the sandbox, the key takeaway is clear: success lies in preparation, experimentation, and a willingness to learn. With the right approach, GenStudio can become a powerful ally in your performance marketing toolkit.

Are you looking for a partner to help with your GenStudio for Performance Marketing implementation? Connect with us.

And if you’re looking for more Adobe expert insights, check out our Adobe blog site!

AEM Universal Editor: A Simpler, Smarter Way to Create Content

Adobe Experience Manager (AEM) has come a long way in empowering content authors. We started with static templates — where even small changes required a developer — and evolved to editable templates and Layout Mode, which finally gave authors visual control over their pages.

Now, Adobe is flipping the script again with the Universal Editor. And at first glance, it might feel like a step backward.

• Layout Mode is gone.
• Custom column controls? Gone too.

For authors used to dragging, dropping, and designing layouts, this can feel like a loss of creative control.

So… what’s really going on?

The Shift from Layout to Experience

The reactions firsthand:

“Where’s Layout Mode?” “Why can’t I just place things wherever I want?”

It’s a valid response. But after spending time with the Universal Editor, I’ve realized this change isn’t about taking power away — it’s about refocusing.

It’s about removing layout distractions and putting the spotlight back on what matters most: creating meaningful, consistent content experiences.

Why Layout Mode Wasn’t the Answer

Layout Mode felt like freedom at first. You could finally design your own pages — no developers needed.

But with that freedom came complexity.

To use it well, authors had to learn:

• Grid systems (8–4 layouts)
• Nested containers
• Margins, paddings, and the infamous box model

Sure, Layout Mode was powerful — but it made content creation more complex than it needed to be.

What Makes the Universal Editor Different?

The Universal Editor brings a fresh approach — one that separates content creation from layout engineering.

Here’s what it introduces:

• Blocks & Section Blocks: Simple building blocks for structured content
• The Properties Rail: A unified editing panel
• Clean HTML output: Faster, more accessible pages
• Content Source Mapping: Bind components to headless content sources
• Document-Based Authoring: Edit directly in the rendered page or email
• Visual Previews Across Channels: Edit content while previewing how it will look across devices and channels

Let’s break these down.

Goodbye Layout Mode, Hello Clean Structure

Layout Mode may be gone, but layout control isn’t.

Instead of manually managing layout containers, authors now build pages using Section Blocks and Content Blocks — all styled using design tokens or CSS classes provided via Edge Delivery Services (EDS).

This shift prevents layout spaghetti and bloated code. The result?

• Cleaner, semantic HTML
• Better SEO and accessibility
• Faster page loads
• Fewer broken layouts

Want columns? You still can — but the approach is smarter and cleaner.

 Visual Authoring: Document-Based, Fragment-Based

Universal Editor allows for:

• Document-Based Authoring: Edit content directly in a fully rendered web page or email. What you see is truly what you get.
• Fragment-Based Authoring: Reuse content fragments like headlines, images, or CTAs across multiple channels.

Whether you’re editing a marketing page, a landing page, or a transactional email, you stay in the context of the real experience.

 JSON-Driven UI & Content Source Mapping

Under the hood, Universal Editor operates on a JSON-driven UI model. That means:

• Developers define what properties are editable
• Authors interact with a lightweight, dynamic interface
• UI and data stay cleanly decoupled

Using content source mapping, you can bind content blocks to headless CMS data, JSON APIs, or structured content fragments. This makes the Universal Editor incredibly flexible — and future-proof.

The Properties Rail: Simple, Unified Editing

Editing in classic AEM was… chaotic. Hidden dialogs, floating pop-ups, custom UIs for each component.

The Properties Rail fixes that. It’s a clean side panel where you can edit any block’s content — all in one place.

Why it rocks:

• Consistent editing across all blocks
• No more UI guesswork
• Fewer clicks, faster changes
• Accessible and keyboard-friendly

It might feel unfamiliar at first, but once you get the hang of it, there’s no going back.

Section Blocks: Structure with Purpose

In the old days, pages could become layout jungles:

• Layouts inside layouts
• Accordions inside tabs inside more accordions
• Way too many nested containers

Section Blocks help authors avoid that. They provide clear boundaries and promote structured, semantic content.

Why they matter:

• Enforce proper heading levels (H1 → H6)
• Help screen readers understand flow
• Boost SEO with cleaner markup
• Make editing and maintaining content easier

Channel Previews: One Editor, Any Experience

The Universal Editor isn’t just for web pages. You can preview and author across:

• Web pages (Sites)
• Emails
• Headless content delivered via APIs
• Single Page Applications (SPAs)

And it all works from the same authoring UI — which makes the experience channel-agnostic.

Why This Change Matters

This isn’t just a tool upgrade — it’s a shift in mindset:

• Authors can focus on storytelling, not structure
• Developers can define reusable, scalable models
• SEO and accessibility come built-in by design

The Universal Editor doesn’t remove flexibility — it refines it. It’s not the freedom we thought we wanted, but it’s the one we actually needed.

Universal Editor Extras

A few more highlights:

• Edge Delivery Services (EDS)
  Integrated delivery via CDN for lightning-fast performance
• Headless & Hybrid Ready
  Works with AEM Sites or headless SPAs
• Visual Authoring Without Developer Bottlenecks
  Developers define structure + styling, authors fill in content = efficiency

 Visual Reference

Universal Editor UI Interface (Forms)

The Universal Editor interface is divided into four logical parts:

    1. A: Experience Cloud Header : The Experience Cloud Header appears at the top of the console and provides navigation context within the broader Adobe Experience Cloud ecosystem. It shows your current location and allows quick access to other Experience Cloud applications.

    2. B: Universal Editor Toolbar : The toolbar provides essential navigation and editing tools. With it, you can move between forms, publish or unpublish forms, edit form properties, and access the rule editor for adding dynamic behaviors.

     3. C: Properties Panel :  The Properties Panel appears on the right side of the interface and displays contextual information based on what you’ve selected in the form. When no component is selected, it shows the overall form structure.

     4. D: Editor : The Editor is the central workspace where you create and modify your form. It displays the form specified in the location bar and provides a WYSIWYG experience that shows exactly how your form will appear to users. In preview mode, you can interact with the form just as your users would, testing navigation through buttons and links.

For More Information, you can refer to this adobe site: Getting Started with the Universal Editor in AEM | Adobe Experience Manager

Adobe launched GenStudio for Performance Marketing and has made many improvements and updates leading up to Adobe Summit 2025. We’ve had an opportunity to use it here at Perficient, and have discovered a number of exciting features (along with nuances) of the product.

We see an evolving future of its rollout, especially as more and more marketing teams adopt the capabilities it has into their own digital marketing ecosystems. 

What GenStudio Is 

GenStudio may very well be a marketer’s dream. We do see it as a game-changer for how marketing content is created, activated, and measured. That’s because it greatly reduces the amount of time that is typically required to request, build, assemble, review, and publish content for marketing campaigns.

These various flows in creating content can now be handled by the AI capabilities of GenStudio. Not only that, but the content generated can follow brand standards and guidelines that are established in GenStudio. 

Some of the main features to highlight: 

• An AI-first approach 
• Brand scoring based on generated content, with feedback review 
• Integrations with existing brand-approved assets 
• Extensibility options 
• Channel activation directly from GenStudio 

We’d like to note that although there are many Generative AI capabilities within creating content, human review is always a part of the approval and publication process. 

GenStudio Use Cases 

There are a few use cases that have been described by Adobe that can be addressed with GenStudio.  

• Reuse of content from previous campaigns across channels 
• Personalization of content to products, offers, and segments 
• Content localization across geos and languages 
• Content optimization based on insights 

Our experience so far has been focused on the content creation process, and seeing how our content looks and behaves in some of our channels. We look forward to creating personalized experiences, along with seeing how the content performs based on things like Content Analytics, recently announced at Adobe Summit. 

The Process

After onboarding, defining users and groups, and establishing some processes for adopting GenStudio, the first step is to establish the Brand Guidelines.  

Brand Setup 

New Brands can be created (along with Storage Permissions) within the interface, either using a guidelines document or manually.    

Expert Tip: Use a PDF document that has all your brand guidelines defined to upload, and GenStudio will create the various guidelines based on the document(s).   

Once a brand is uploaded, review the guidelines, add new ones, and make necessary adjustments.  

The following example illustrates the WKND brand: 

Note that the permissions to edit and publish a brand should be kept to brand owners. Changes to the brand which are then published may also impact other systems that use these brand guidelines, such as Adobe Experience Manager, or Orchestration Agents. 

Once the brand has been published, it can then be used to generate emails, meta ads, banner ads, and other display ads.  

Content Creation 

Content creation is based on templates. These templates allow the creation of content that may greatly reduce the amount of time to build out content with existing tools. What we would like to see eventually from Adobe in this area is the ability to create and design layouts within the tool, as opposed to having to upload HTML files that need to adhere to certain frameworks. Another approach may be to create a process that can reference existing layouts such as emails from Marketo, or Experience Fragments in AEM, and them brought into GenStudio. 

Assets can also be brought into GenStudio and then used in generating content. Assets that are managed in AEM as a Cloud Service can also be used.  

Note: The Assets that are part of AEMaaCS need to be marked as “Approved” before being made available in GenStudio. Assets can also be sourced from ContentHub.  

Expert tip: Because there are several ways of sourcing Assets that are brought into GenStudio, we suggest working with a partner such as Perficient to guide these processes. 

Example content generation for an event at Adobe Summit:

Content Review 

After the content creation process, content can then be sent for approval. For example, in the above display ad, a content reviewer may ask for re-phrasing to help improve the brand score, if appropriate. Once approved, the content is then published as part of a campaign and can be downloaded in the form of HTML, images, or CSV files for publication. 

Content Activation 

Activating content can also be done on various channels such as Meta, Google Campaign Manager 360, and others. (Note that as of this writing, 3/19/25, the only channel available for activation is Meta.) Once these additional channels are rolled out, we look forward to exploring those capabilities and insights based on those channels, which is another feature available as part of GenStudio.  

Excited About the Future of GenStudio 

We’re excited about the features that Adobe GenStudio for Performance Marketing provides now, and what will be rolled out over time as features become available. Working with the tool itself feels slick, and having the Generative AI features built on top of it makes us feel like we’re really using some cutting-edge technologies. 

Our Adobe experts are heading to Vegas this month to attend Adobe Summit, connect with industry leaders, and learn about Adobe’s latest innovations. The conference will provide plenty of opportunities to learn how to grow your business and deliver exceptional digital experiences.

In the video below, Perficient principals Robert Sumner and Ross Monaghan have identified the top three topics they are excited to hear about: GenStudio, the rise in B2B features, and personalization.

Check out the video and learn more about why they’re excited and make sure to check out all the ways you can engage with us if you’re attending Summit as well.

Watch: Why Our Experts Are Excited About GenStudio, B2B, and Personalization

Meet Us at Adobe Summit

Going to Adobe Summit? Find out how to connect with us!

Learn more.