Architecture, engineering & leadership

Practical lessons from building digital platforms and leading engineering teams.

Shatrughna Kumar · Solution Architect

Featured deep dive

Sitecore Content SDK Data Flow

Follow content from authoring through to Next.js rendering. →

Explore topics

ArchitectureSystem design · Integration Software Engineering.NET · C# · Next.js Digital ExperienceCMS · Sitecore · Headless delivery Cloud & DevOpsAzure · AWS · Observability AI EngineeringAgents · Integration · Evaluation Engineering LeadershipTeams · Delivery · Technical decisions

Browse Sitecore by product XM Cloud Content Hub CDP Personalize Search

Pages

November 22, 2026

Modernizing a Website Is More Than Moving Content: A New Perspective with SitecoreAI

Modernizing a Website Is More Than Moving Content: A New Perspective with SitecoreAI When we discuss website modernization, the conversation...

Modernizing a Website Is More Than Moving Content: A New Perspective with SitecoreAI

When we discuss website modernization, the conversation often starts with technology. Which CMS should we use? How much effort will migration require? Can we reuse our existing components? What happens to thousands of pages already published?

These are important questions, but I believe there is another question worth asking:

Are we simply moving an existing website to a new platform, or are we using this opportunity to build something better?

This is where I find the approach behind SitecoreAI Pathway interesting.

Sitecore has introduced an AI-assisted approach that helps organizations move existing website content into SitecoreAI. Rather than treating migration purely as a data transfer exercise, it introduces a structured process for understanding existing content, identifying patterns, mapping content structures, and moving them into a new digital experience environment.

Understanding What We Already Have

One of the biggest challenges in enterprise CMS modernization is understanding the existing website.

Over the years, websites accumulate hundreds or thousands of pages, different templates, reusable components, and sometimes inconsistent content structures.

Not everything deserves to be migrated.

Some content may be outdated. Some pages may have similar structures but use different templates. Other pages may no longer support current business goals.

Before thinking about migration, I would first want to understand the existing content landscape.

This is one area where SitecoreAI Pathway offers an interesting capability. Its AI-assisted content audit can identify pages with similar structures and help map existing templates to the target environment.

For an architect, this is valuable because it gives us an opportunity to make better decisions about the future content model instead of blindly carrying forward years of complexity.

Making Migration More Predictable

Traditional CMS migrations often involve significant manual analysis, extraction scripts, mapping spreadsheets, custom utilities, and repeated validation.

SitecoreAI Pathway introduces a more guided approach.

It supports migrations from existing Sitecore XM/XP implementations and publicly accessible non-Sitecore websites. Depending on the source, the process uses Sitecore data extraction or AI-powered website crawling.

The migration workflow brings together source selection, target configuration, content analysis, template and component mapping, and migration execution.

What I particularly like about this approach is the opportunity to reduce repetitive work.

Instead of manually examining every page and deciding where each element belongs, teams can use AI-generated mapping suggestions as a starting point.

Of course, this does not mean every suggestion will be correct. The target architecture still needs to be designed, and the results need to be reviewed.

AI can help us move faster, but architectural decisions should remain intentional.

A Better Opportunity to Redesign the Content Model

This is probably the most interesting part for me from a solution architecture perspective.

Imagine an organization running a large website that has evolved over several years.

It may have multiple templates serving nearly identical purposes, components created for one-off requirements, and content structures that are difficult for editors to maintain.

If we migrate everything exactly as it exists, we may successfully change the technology while retaining the same design problems.

With SitecoreAI Pathway, teams can review existing content patterns and guide how source templates and components map to the new SitecoreAI environment.

This creates an opportunity to consolidate unnecessary variations, establish more reusable content structures, and improve consistency across the website.

The tool supports AI instructions for refining template and component mapping, allowing teams to review and adjust the results before proceeding.

For me, the real value is not simply getting content into a new CMS.

It is making sure the content is structured in a way that supports future business requirements.

Where I See the Business Value

From a business perspective, an AI-assisted migration approach could provide several advantages.

Reduced manual effort: Teams can spend less time on repetitive content classification and mapping activities.

Better migration planning: A clearer understanding of existing content helps identify complexity before execution.

Improved content consistency: Similar page structures can be reviewed together rather than treated as entirely separate implementations.

More controlled modernization: Organizations can plan migration in phases instead of moving an entire website at once.

Greater focus on experience improvements: Development and content teams can spend more time on usability, content quality, and business requirements.

These are potential benefits, not guaranteed outcomes. The actual savings depend on content quality, existing architecture, integrations, and the amount of refinement required.

The Architect's Responsibility Does Not Disappear

Whenever AI becomes part of an engineering process, it is tempting to assume that more automation means less architectural involvement.

I see it differently.

SitecoreAI Pathway can assist with content mapping and migration, but it is not a one-click replacement for solution design.

The destination site and its components must be prepared. Teams still need to validate the migrated content, template mappings, component behavior, and migration results.

I would also keep several important areas under architectural review: SEO and URL continuity, localization, integrations, accessibility, publishing workflows, and performance.

These considerations are especially important for enterprise websites where successful migration means more than seeing pages render correctly.

An architect still needs to define what success looks like, identify risks, establish validation criteria, and make sure the new platform supports the organization's longer-term direction.

My Closing Thoughts

I see SitecoreAI Pathway as an interesting development in how we approach CMS modernization.

For years, a significant portion of migration effort has gone into understanding existing content, mapping structures, and writing utilities to move data between platforms.

AI-assisted migration offers an opportunity to simplify some of that work.

But the bigger opportunity is to rethink what should move, what should change, and what should be left behind.

A successful modernization project should not be measured only by how many pages were migrated or how quickly a new platform went live.

It should also be measured by whether the organization ends up with a cleaner architecture, more maintainable content, and a better foundation for future digital experiences.

Moving content is a technical activity. Modernizing the experience is an architectural decision.

And that distinction matters.

November 18, 2026

10 Must-Read Books for Software Architects — And Why You Should Read Them

  10 Must-Read Books for Software Architects — And Why You Should Read Them Over the years, I have realized that becoming a better Software ...

 

10 Must-Read Books for Software Architects — And Why You Should Read Them



Over the years, I have realized that becoming a better Software Architect is not just about learning new frameworks, cloud platforms, or programming languages.

It is about developing the ability to make better technical decisions, understand trade-offs, communicate effectively, and connect technology with business goals.

Books are one of the best ways to learn from experienced architects who have already faced complex engineering challenges.

Here are 10 books I believe every aspiring or experienced Software Architect should have on their reading list.

1. Fundamentals of Software Architecture

Authors: Mark Richards and Neal Ford

Why read it?

An excellent starting point for understanding architectural styles, quality attributes, architecture characteristics, and decision-making.

It helps you understand why architecture is more than choosing technologies.

Key learning: Think like an architect, not just a senior developer.

2. Clean Architecture

Author: Robert C. Martin

Why read it?

This book explains how to design maintainable, testable, and loosely coupled systems using clear boundaries and dependency principles.

Particularly valuable for architects working with .NET, Java, and enterprise applications.

Key learning: Good architecture should protect business logic from unnecessary technology dependencies.

3. Software Architecture: The Hard Parts

Authors: Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani

Why read it?

Real-world architecture rarely has perfect answers. This book explores distributed systems, service boundaries, data ownership, and difficult architectural trade-offs.

Key learning: Architecture is about evaluating trade-offs, not searching for a perfect solution.

4. Designing Data-Intensive Applications

Author: Martin Kleppmann

Why read it?

A valuable resource for understanding distributed systems, data storage, replication, consistency, reliability, and scalability.

Especially useful when designing high-volume enterprise systems.

Key learning: Understand what happens to data as systems grow in complexity and scale.

5. Domain-Driven Design

Author: Eric Evans

Why read it?

This book teaches how to align software design with complex business domains.

It introduces concepts such as bounded contexts, aggregates, entities, and ubiquitous language.

Key learning: Understand the business domain before designing the technical solution.

6. Building Evolutionary Architectures

Authors: Neal Ford, Rebecca Parsons, and Patrick Kua

Why read it?

Architecture should support change rather than resist it. This book explores how systems can evolve while preserving important architectural characteristics.

Key learning: Design systems that can adapt as business requirements change.

7. Patterns of Enterprise Application Architecture

Author: Martin Fowler

Why read it?

A classic reference covering enterprise application patterns, business logic organization, persistence, and data mapping.

Particularly helpful when modernizing legacy applications.

Key learning: Many modern engineering problems have well-established architectural patterns.

8. The Software Architect Elevator

Author: Gregor Hohpe

Why read it?

One of my strongest recommendations for architects moving toward Principal Architect, Enterprise Architect, or technology leadership roles.

It explains how architects can connect implementation teams with business strategy and executive leadership.

Key learning: A successful architect must connect technical decisions with organizational goals.

9. Team Topologies

Authors: Matthew Skelton and Manuel Pais

Why read it?

Architecture is not only about systems. Team structure, communication, cognitive load, and ownership also influence delivery.

This book provides useful ideas for organizing teams around software delivery.

Key learning: Effective architecture requires effective team interactions.

10. Release It!

Author: Michael T. Nygard

Why read it?

A practical guide to building production-ready software, covering stability, resilience, failure handling, and operational risks.

A useful reminder that software architecture must work beyond development environments.

Key learning: A successful solution must remain reliable when real-world failures occur.

Which Book Should You Read First?

If you are beginning your Software Architecture journey, start with Fundamentals of Software Architecture and Clean Architecture.

If you are already working as a Technical or Solution Architect, focus on Software Architecture: The Hard Parts, Designing Data-Intensive Applications, and Building Evolutionary Architectures.

If your goal is to move toward Principal Architect, Enterprise Architect, or technology leadership, prioritize The Software Architect Elevator, Domain-Driven Design, and Team Topologies.

Reading books alone will not make someone a great architect.

The real value comes when we connect what we read with actual project challenges.

Whenever you complete a chapter, ask yourself:

  • Where can I apply this concept in my current project?

  • What architectural decision would I make differently?

  • What trade-offs should I consider?

  • How can I explain this concept to my team?

My simple belief: An architect should never stop learning, questioning, and improving.

Technology changes, but strong architectural thinking remains valuable.

And sometimes, one good book can change how we approach an entire project.

November 17, 2026

Sitecore Symposium 2026: Key Takeaways and the Future of Digital Experiences

  Sitecore Symposium 2026: Key Takeaways and the Future of Digital Experiences Sitecore Symposium 2026  Sitecore Symposium 2026, held under ...

 

Sitecore Symposium 2026: Key Takeaways and the Future of Digital Experiences




Sitecore Symposium 2026 

Sitecore Symposium 2026, held under the theme “Marketing Rewired,” highlighted how artificial intelligence is reshaping digital experiences, content operations, marketing, and customer engagement.

This year's Symposium was particularly interesting because the conversation moved beyond traditional content management and personalization toward AI-powered discovery, intelligent workflows, and agent-driven experiences.

Here are some of the key announcements and takeaways that stood out to me.

MarketingIQ: Bringing Intelligence into Marketing Operations

One of the major announcements was MarketingIQ, a new capability within SitecoreAI designed to connect brand intelligence, marketing insights, and campaign execution.

The idea is to help marketing teams move from insights to action more efficiently, using AI-assisted workflows while maintaining human oversight and approval.

Scrunch: A New Perspective on AI Discoverability

With customers increasingly using ChatGPT, Gemini, and other AI platforms to discover products and services, traditional SEO alone may no longer provide the complete picture.

Sitecore highlighted its integration with Scrunch, helping organizations understand how their brands appear in AI-generated responses.

Scrunch also introduced Citation Optimization, focusing on the external sources influencing AI recommendations.

Sitecore Developer MCP: AI-Assisted Development

Another interesting development was the beta release of the Sitecore Developer MCP server, documented immediately after Symposium.

It enables compatible AI coding assistants to interact with SitecoreAI capabilities, including component management, content modeling, and content creation.

From a development perspective, this could reduce repetitive activities and make AI-assisted Sitecore development more practical.

AI Agents and the Changing Digital Experience Landscape

A recurring direction was the increasing role of AI agents in marketing operations and customer interactions.

Digital experiences may increasingly need to support not only human visitors but also AI assistants interacting with enterprise platforms.

This brings additional importance to APIs, integration patterns, authentication, structured content, and governance.

Content Hub and Content Governance

Another important takeaway was the continuing relevance of governed digital assets and structured content.

As AI becomes more involved in content operations, having reliable metadata, approved assets, clear ownership, and well-defined content models becomes even more important.

AI can accelerate content operations, but content governance remains essential.

My Takeaway from an Architecture Perspective

Looking at these developments, I see three areas becoming increasingly important for Sitecore architects:

  • AI-ready content architecture: Structuring content and assets for reuse, discoverability, and intelligent consumption.

  • Integration and interoperability: Connecting content platforms, AI services, and business applications through secure, scalable integration patterns.

  • Governance and control: Ensuring AI-assisted workflows operate within defined permissions, approval processes, and business rules.

Sitecore Symposium 2026 reinforced that digital experience platforms are evolving beyond managing and delivering content.

The direction is moving toward connecting content, intelligence, automation, and customer engagement into a more coordinated ecosystem.

For me, the key message is simple:

AI will increasingly influence how digital experiences are created, discovered, and delivered. But strong architecture, structured content, and good governance will remain the foundation of successful implementations.


November 13, 2026

How Sitecore Page Builder Talks to Your Next.js App: A Sequence Diagram Explained

  How Sitecore Page Builder Talks to Your Next.js App: A Sequence Diagram Explained When a content author opens a page in the SitecoreAI Pa...

 

How Sitecore Page Builder Talks to Your Next.js App: A Sequence Diagram Explained

When a content author opens a page in the SitecoreAI Page builder and starts editing, it feels like magic. The page appears, exactly as visitors will see it, and every text field and component is editable right there in the browser. But behind that smooth experience is a carefully choreographed conversation between Sitecore and your Next.js application.

In this post, I’ll walk through that conversation using a sequence diagram, one of the most useful tools in a solution architect’s toolkit.

Why a Sequence Diagram?

Most architecture diagrams show what exists: systems, databases, and connections. A sequence diagram shows something different: what happens, in what order. Time flows from top to bottom, each participant gets a vertical line called a lifeline, and arrows show messages passing between them.

For understanding a flow like editing, where several systems call each other in a chain, nothing beats a sequence diagram.


Meet the Participants

The diagram has five participants. The Author is the person editing content. The Page builder is SitecoreAI’s visual editor. The Render API and the Page route both live inside the editing host, which is a special instance of your Next.js app that never serves public visitors and exists only to support editing. Finally, the Preview GraphQL endpoint supplies draft, unpublished content.

The colors tell you who owns what: teal boxes are hosted by Sitecore, and coral boxes are part of your editing host, which your team builds and maintains.

The Flow, Step by Step

Steps 1 and 2: The author opens a page, and the Page builder sends a request to the editing host’s Render API route. This request carries details like which item, language, and site to render, along with a secret token.

Step 3: The Render API checks that the secret is valid. This self-arrow, looping back to its own lifeline, shows work happening inside one participant. If the secret is wrong, the request is rejected with a 401 error, which protects your editing endpoints from outsiders.

Step 4: The Render API switches on Next.js preview mode and asks the page route to render the page. Preview mode is important because it skips static generation and renders fresh at request time, so authors always see their latest drafts.

Steps 5 and 6: The page route fetches draft content from the Preview GraphQL endpoint. What comes back is not just content but also metadata describing every placeholder, component, and field on the page.

Steps 7 to 9: The rendered HTML travels back up the chain to the Page builder, which uses that metadata to make each part of the page editable for the author.

Notice the arrow styles: solid arrows are requests, and dashed arrows are responses coming back.


November 12, 2026

A Form Submission Is More Than an API Call: Architecture Lessons from SitecoreAI Forms

  A Form Submission Is More Than an API Call: Architecture Lessons from SitecoreAI Forms Architecture Lessons from Real Implementations | Si...

 

A Form Submission Is More Than an API Call: Architecture Lessons from SitecoreAI Forms

Architecture Lessons from Real Implementations | SitecoreAI Forms · Next.js · Webhooks · Pardot

While working on a recent SitecoreAI Forms implementation, one of the interesting architecture lessons came from something that initially looked straightforward: submitting a contact form.

From a user's perspective, the experience is simple. Fill in a few fields, click Submit, and receive a confirmation message.

But behind that small interaction, several systems must communicate correctly. There are questions around authentication, data validation, field mapping, external integrations, error handling, and what actually constitutes a successful submission.

That experience reinforced an important point for me: a form submission is not just an API call. It is an integration workflow with multiple responsibilities.

Understanding the end-to-end architecture

The implementation involved SitecoreAI Forms, a Next.js application, a webhook-based integration, and a downstream marketing automation system.


The flow can be understood in five stages.

1. Form creation and configuration

SitecoreAI Forms provides the ability to configure form fields, layouts, validations, and submission behavior. Content authors can manage the form without needing to modify the frontend application for every small change.

This gives marketing and content teams flexibility while keeping custom integration logic outside the form configuration.

2. Submission through a webhook

When the visitor submits a form, SitecoreAI Forms sends the captured information to a configured webhook endpoint.

SitecoreAI Forms follows a fire-and-forget model for submitted data: the platform forwards the information to the webhook rather than acting as the permanent storage location for form submissions.

3. Processing through a Next.js API

In our implementation, the Next.js API route acted as an integration layer.

Instead of connecting the form directly to the destination marketing platform, we introduced an endpoint responsible for accepting the webhook request, verifying its authenticity, validating the payload, and preparing the data for the downstream system.

This separation made it easier to keep the destination-specific logic in one place.

4. Data transformation and mapping

One challenge in an integration like this is that the source form and the destination system do not necessarily use the same field structure.

For example, a form field named firstName might need to be mapped to first_name in another system.

The integration layer becomes responsible for translating one data contract into another. This also creates a place to handle optional fields, missing values, and validation rules.

5. Delivery to marketing automation

Once the payload has been validated and transformed, the integration forwards the information to the Pardot Form Handler.

The important distinction is that receiving the request successfully at the Next.js endpoint does not automatically guarantee that Pardot has accepted and processed the information.

Each stage has its own responsibility and its own potential failure conditions.

The architecture decisions that mattered

1. Keep form configuration separate from integration logic

A form should not need to understand the internal details of every downstream system.

The form is responsible for collecting information. The integration layer is responsible for delivering that information in a format the receiving system understands.

This separation also makes future changes easier. If the destination API changes, there should ideally be no need to redesign the form itself.

2. Treat webhook endpoints as security boundaries

Webhook endpoints are externally accessible integration points.

In our Next.js implementation, authentication using a configured webhook key was an important part of the design.

A receiving endpoint should verify the incoming request before processing it. Additional safeguards such as strict payload validation, secret management, appropriate logging, and rate limiting should also be considered.

SitecoreAI Forms supports webhook authentication options including API key, Basic authentication, and OAuth 2.

Sitecore Documentation+1

3. Design data mapping as a separate responsibility

It is tempting to place every validation rule, field conversion, and destination-specific detail inside a single API handler.

That may work initially, but it becomes difficult to maintain as the number of fields or integrations increases.

A better design is to keep request authentication, payload validation, transformation, and destination communication logically separated.

Even when implemented within one application, these responsibilities should remain distinguishable.

4. Be careful with the meaning of success

This was one of the more useful lessons.

Consider a submission that moves through three different stages:

  • SitecoreAI successfully sends the webhook.

  • The Next.js endpoint receives and processes the request.

  • Pardot accepts the transformed data.

A successful HTTP response at one stage does not necessarily establish that every subsequent business operation succeeded.

Sitecore's documentation also distinguishes between webhook delivery and an unsuccessful application-level response, which is important when diagnosing submission failures.

For a reliable integration, it is essential to define what success means, where errors are recorded, and how failed submissions can be investigated or recovered.

5. Think about observability before production

A form submission may travel through several systems, making failures difficult to troubleshoot without sufficient diagnostic information.

Useful operational information includes a correlation identifier, submission timestamp, integration name, processing result, destination response status, and sanitized error details.

At the same time, logging should not unnecessarily expose personal information submitted by visitors.

Where delivery guarantees are important, a durable queue or another recovery mechanism can be considered rather than relying entirely on a synchronous integration. That is an architectural option, not a component that was necessarily required in our implementation.

A practical lesson from the implementation

What made this work interesting was not the complexity of the form interface.

It was the number of boundaries involved in moving data from a content-managed experience to an external business system.

The same pattern can appear in many other integrations: CRM lead capture, newsletter subscriptions, event registration, customer enquiries, and support requests.

A form may look like a small frontend feature, but its reliability depends on decisions made across several layers of the application.

Working on SitecoreAI Forms was a useful reminder that architecture is not always about large systems, complicated diagrams, or introducing new technologies.

Sometimes, it is about understanding the responsibilities hidden behind a simple user interaction.

The user sees a Submit button. The architect needs to think about everything that happens after it is clicked.

And often, getting those boundaries right is what makes a simple feature reliable in production.

November 10, 2026

SitecoreAI Audiences Building More Relevant Digital Experiences Through Smarter Visitor Segmentation

  SitecoreAI Audiences Building More Relevant Digital Experiences Through Smarter Visitor Segmentation Personalization has become an importa...

 

SitecoreAI Audiences Building More Relevant Digital Experiences Through Smarter Visitor Segmentation

Personalization has become an important part of modern digital experience platforms. Almost every organization wants to deliver relevant content, improve customer engagement, and create experiences that match individual visitor expectations.

However, personalization does not begin with changing a banner, recommending a product, or displaying different content on a page.

It begins with understanding the visitor.

Before deciding what experience should be delivered, we need to understand who the visitor is, what they are interested in, and how they have interacted with our digital channels.

This is where Audiences in SitecoreAI become valuable.

Audience management provides a structured way to identify groups of visitors based on shared characteristics and behaviors. These groups can then support personalization, campaign targeting, customer engagement, and other marketing activities.

More importantly, audiences help organizations move away from isolated targeting rules toward a more consistent approach to understanding their visitors.

Why Audience Management Matters

Consider a website that receives thousands of visitors every day.

Some visitors are exploring the website for the first time. Others have visited several times and already understand the products or services being offered.

A few might be researching a particular product, while others are comparing pricing or looking for technical documentation.

If we deliver the same content to every visitor, we may be missing opportunities to provide a more meaningful experience.

For example, imagine a technology company offering cloud solutions, AI services, and enterprise consulting.

A visitor who repeatedly explores AI-related articles may be more interested in an upcoming AI webinar than someone who has only visited the company's career page.

Similarly, someone who has visited the pricing page several times may benefit from a product consultation or additional information that helps with their decision.

These are different visitor intentions, and they deserve different engagement strategies.

But identifying these visitors consistently can become difficult when audience conditions are created separately across multiple personalization activities or campaigns.

Over time, similar targeting rules may be duplicated, modified independently, or interpreted differently by different teams.

Audience management helps address this problem by allowing teams to define reusable visitor segments in a more organized way.

What Are Audiences in SitecoreAI?

In SitecoreAI, audiences represent groups of visitor profiles that satisfy a defined set of conditions.

These conditions can be based on information associated with a visitor profile, including contextual attributes and recorded interactions.

For example, we might create an audience for visitors from Canada who are browsing the website in English.

Another audience could represent visitors who have repeatedly explored a particular category of content.

The important point is that audiences are not necessarily tied to one page, one campaign, or one personalization activity.

They represent a reusable definition of a visitor group.

Once created, an audience can provide a common foundation for relevant downstream experiences and marketing activities, subject to the capabilities and integrations available in the implementation.

This separation between defining an audience and deciding how to engage that audience is particularly useful.

It allows teams to focus on two different questions:

Who are we trying to reach?

And:

What experience should we deliver to them?

These questions are closely related, but they should not always be implemented as one tightly coupled piece of logic.

Understanding Contextual and Behavioral Segmentation

Audience definitions become more useful when we understand the different types of information that can contribute to them.

Contextual Information

Contextual information describes the circumstances surrounding a visitor's interaction.

Examples include:

  • Geographic location

  • Preferred language

  • Device type

  • Campaign source

  • Referral information

  • Other available visitor attributes

Suppose an organization operates in multiple countries and offers region-specific products.

Visitors from Canada may need access to different product information, regulatory notices, or regional campaigns than visitors from the United States.

A location-based audience can help identify relevant visitor profiles.

However, location alone does not necessarily tell us what a visitor wants.

It tells us something about their context.

That is why contextual targeting is often more useful when combined with other information.

Behavioral Information

Behavioral information helps us understand how visitors interact with digital experiences.

Depending on the data collected and the audience conditions supported by the platform, this information may include:

  • Pages or content categories visited

  • Repeated visits

  • Product interactions

  • Campaign engagement

  • Registration activities

  • Custom events or profile attributes

Consider two visitors who arrive on the same product page.

The first visitor arrived through a search engine and has never visited the website before.

The second visitor has returned several times, read technical documentation, and explored the pricing section.

Although both visitors are viewing the same page, their level of engagement may be different.

Behavioral information can help distinguish between them.

One important consideration is that behavioral segmentation depends on the quality of the data being collected.

If events are missing, incorrectly named, or inconsistently implemented, the resulting audience may not accurately represent the intended group of visitors.

This is something development and architecture teams should consider early in an implementation.

Practical Examples of Audience Management

The value of audiences becomes clearer when we look at some practical scenarios.

1. Engaging Returning Visitors

Imagine an organization that wants to provide more advanced product information to visitors who have already explored its website.

Instead of showing introductory content every time, the organization could define an audience representing returning visitors.

The experience might include more detailed product information, comparison resources, or relevant case studies.

The objective is not simply to show different content. It is to recognize that returning visitors may be at a different stage of their research.

However, returning to a website does not automatically mean someone is ready to purchase. The audience should be treated as an indicator of potential interest rather than a confirmed buying intention.

2. Identifying Visitors Interested in AI

Suppose a technology company regularly publishes articles about artificial intelligence, machine learning, and automation.

It also organizes webinars and technical sessions.

The marketing team wants to promote an upcoming AI webinar to people who have already demonstrated interest in related topics.

An audience could be defined using relevant page interactions, registered interests, or other available behavioral information.

Once the matching profiles are identified, the organization can use that information to support more relevant promotional activities.

This is generally more meaningful than presenting the same webinar promotion to every visitor regardless of their interests.

3. Supporting First-Time Visitors

A first-time visitor may need more introductory information than someone who already knows the organization.

For example, an enterprise software website might want to encourage new visitors to explore its core capabilities or register for additional resources.

An audience representing new visitors could support an introductory experience.

This might include a product overview, a getting-started guide, or a registration invitation.

The goal is to help visitors discover relevant information without overwhelming them with content intended for people who are already familiar with the platform.

4. Understanding Pricing Page Engagement

One particularly interesting scenario involves visitors who repeatedly review pricing information.

Repeated pricing-page visits may suggest that a visitor is evaluating a product or comparing alternatives.

An organization could define an audience based on relevant pricing-page interactions, provided the necessary events and conditions are available.

This audience might be used to support product comparison content, consultations, frequently asked questions, or relevant follow-up campaigns.

There is an important distinction here.

Visiting a pricing page multiple times does not prove that someone intends to make a purchase.

It is simply a behavioral signal.

Good audience design should recognize these limitations rather than making assumptions that the collected data cannot support.

Why Reusable Audiences Are Important

One of the most useful aspects of audience management is reusability.

Without a centralized approach, different teams may define similar visitor groups independently.

For example, one marketing campaign might identify returning visitors using a particular visit threshold.

Another campaign may use a different threshold.

A personalization activity might use yet another condition.

All three activities could be described as targeting returning visitors, but they may actually be reaching different groups of people.

This creates inconsistency.

With reusable audiences, teams can establish a common definition and maintain it in one place.

This provides several practical benefits.

Consistency across activities

Teams can work from shared audience definitions rather than independently interpreting the same business requirement.

Simpler maintenance

When business requirements change, audience conditions can be reviewed and updated centrally instead of locating similar rules across multiple implementations.

Better collaboration

Marketing teams, developers, analysts, and solution architects can discuss the same audience definition.

Improved governance

Organizations can establish naming conventions, ownership, and review processes for important audience segments.

There is also an architectural advantage.

Audience definitions become easier to manage when they are treated as reusable business capabilities rather than conditions embedded directly into individual experiences.

However, changes to a shared audience should always be assessed for their downstream impact.

A small adjustment to an audience definition could affect multiple personalization or campaign activities that depend on it.

Estimating Audience Size Before Activation

Another useful capability is the ability to estimate the number of profiles that match an audience definition before activation.

This helps teams understand whether their conditions are too broad or too restrictive.

Suppose a marketing team creates an audience for visitors who:

  • Are located in Canada

  • Have interacted with AI-related content

  • Have returned to the website multiple times

The conditions might appear reasonable from a business perspective.

But if only a very small number of profiles match, the audience may not be useful for the intended campaign.

On the other hand, if a very large proportion of visitors qualify, the conditions may not be specific enough.

Audience estimation provides a way to evaluate these possibilities before making the audience live.

It is important to understand that an estimate is not a guarantee of future campaign reach or results.

Actual eligibility and activation can depend on profile data, identity resolution, consent, evaluation timing, and the capabilities of the destination where the audience is used.

Still, estimation is a useful step when designing and validating segmentation rules.

What Happens When an Audience Goes Live?

Creating an audience definition and activating it are two different stages.

During audience creation, the team defines the conditions that determine which profiles should qualify.

Once the audience is made live, the platform can evaluate matching profiles and maintain relevant audience membership information according to its supported behavior.

This membership information can then help identify which profiles belong to a particular audience.

The important consideration is that audience membership is not the same as immediate personalization.

An audience identifies a relevant group of profiles.

A personalization or campaign activity still needs to use that information through an appropriate activation mechanism.

This distinction becomes particularly important when multiple systems are involved.

For example, a website may use SitecoreAI for content management while customer profile information and marketing activities involve other Sitecore products or integrations.

The architecture needs to account for how visitor identities are recognized, how information flows between systems, and when audience membership becomes available for use.

Not every audience will necessarily be evaluated or activated in real time at the moment a visitor opens a page.

These details should be verified against the specific platform capabilities and configuration being used.

Audience Management and Personalization

Audiences and personalization complement each other, but they solve different problems.

Audience management focuses on identifying relevant visitor groups.

Personalization focuses on determining the experience those visitors should receive.

For example, consider a website serving both new and existing customers.

An audience could identify profiles associated with existing customers.

A personalization activity might then use that information to display relevant product resources or account-related content.

Similarly, an audience interested in AI topics might be a suitable target for an AI webinar promotion.

However, the relationship between audiences and personalization should not be viewed as purely technical.

The business objective must be clear.

We should not personalize a page simply because audience information is available.

There should be a reasonable expectation that the experience will help the visitor accomplish something more effectively.

This is where the quality of the personalization strategy matters more than the number of audiences created.

Audience Management from an Architecture Perspective

From a solution architecture perspective, audience management introduces several important considerations.

1. Start with Business Objectives

Before creating an audience, understand why it is needed.

A requirement such as "create an audience for returning visitors" is incomplete.

We should also understand what the organization intends to do with that audience.

Is the objective to improve registration?

Promote a particular service?

Support existing customers?

Increase engagement with technical content?

The answers influence how the audience should be defined and how its effectiveness should be measured.

2. Design the Tracking Strategy Carefully

Behavior-based audiences depend on the information collected from visitor interactions.

For example, if a business wants to identify visitors interested in a particular product category, the application must capture suitable information to distinguish those interactions.

This requires coordination between business teams, analytics specialists, and developers.

Event naming, data structure, identity handling, and tracking consistency all matter.

An audience can only be as reliable as the data used to build it.

3. Avoid Creating Too Many Audiences

It can be tempting to create a separate audience for every small variation in a campaign requirement.

Over time, this approach can introduce unnecessary complexity.

Audiences may overlap, become outdated, or exist without any active business use.

A better approach is to establish a manageable set of meaningful audiences and expand them when there is a clear requirement.

Every audience should have a defined purpose and preferably an owner responsible for maintaining it.

4. Consider Identity and Data Quality

Visitor identity is not always straightforward.

A person may browse anonymously, return using another device, or sign in during a later visit.

Depending on the available identity resolution capabilities, those interactions may or may not be associated with the same profile.

This can affect audience membership.

For implementation teams, it is important to understand how profiles are created, recognized, and associated with visitor activities.

Without that understanding, audience-based experiences may behave differently from what the business expects.

5. Plan for Privacy and Consent

Audience management often relies on visitor information, so privacy cannot be treated as an afterthought.

Tracking and targeting must respect applicable privacy requirements, consent preferences, and organizational policies.

For example, when visitor consent is required for particular tracking activities, the implementation should ensure those activities are handled appropriately.

Teams should also avoid collecting unnecessary personal information simply because it might be useful for segmentation later.

A reliable audience strategy depends not only on collecting data but also on managing it responsibly.

6. Measure Actual Business Outcomes

An audience may contain thousands of profiles and still deliver very little business value.

Audience size is not the primary measure of success.

We should look at what happens when the audience is used.

Did the targeted experience improve engagement?

Did visitors find information more easily?

Did registrations increase?

Was there any measurable improvement compared with a suitable control group?

These questions help determine whether the audience definition and associated experience are actually useful.

A Practical Approach to Implementing Audiences

For a real implementation, I would approach audience design in a structured way.

First, identify the business scenarios where segmentation could improve the visitor experience.

Next, review whether the required visitor information is already being collected and whether its quality is sufficient.

Then define the audience conditions clearly, including what qualifies a profile and what should exclude it.

Before activation, evaluate the estimated audience size and validate the rules using representative profiles and interactions wherever the platform supports such testing.

Once the audience is live, confirm that matching profiles are evaluated and that the intended downstream activities can use the membership information.

Finally, measure the outcomes and refine the approach based on actual results.

This process is more useful than creating several audiences without understanding how they will contribute to the overall digital experience.

Common Mistakes to Avoid

There are a few problems that can reduce the effectiveness of audience management.

One is creating audiences without a clear business purpose.

Another is depending on behavioral information without verifying whether the necessary tracking has been implemented correctly.

Audience overlap is another consideration. A single profile may qualify for several different audiences.

For example, someone could simultaneously belong to a returning visitor audience, an AI interest audience, and a pricing engagement audience.

This is not necessarily a problem.

However, teams need to consider how overlapping audience memberships affect campaign prioritization and personalization decisions.

It is also important to avoid assuming that audience membership is permanent.

Visitor interests and behavior can change, and audience evaluation rules may change over time.

Organizations should understand how membership is updated and whether the resulting behavior aligns with the intended use case.

Lastly, audiences should not become a substitute for a well-designed content strategy.

Even the most accurately defined audience will provide limited value if the content being delivered is not relevant or useful.

What I find interesting about audience management is that it addresses a problem that becomes increasingly visible as digital platforms grow.

Initially, segmentation is often simple.

A few conditions are defined for a campaign, a personalization activity, or a specific page.

But as more experiences are introduced, those conditions can become scattered across different activities and systems.

Maintaining consistency becomes difficult.

A reusable audience model offers a more organized way to manage this complexity.

For marketers, it provides a clearer way to identify and engage meaningful groups of visitors.

For developers, it reinforces the importance of reliable tracking and consistent visitor data.

For architects, it introduces an opportunity to establish a more maintainable approach to segmentation, integration, governance, and activation.

However, creating an audience is only the beginning.

The real value comes from connecting audience definitions to meaningful experiences and measuring whether those experiences improve customer outcomes.

Good personalization is not about showing different content to every visitor. It is about understanding when a different experience is genuinely useful.

And that understanding begins with knowing your audience.


05 / THE ARCHITECT BEHIND THE WORK

A builder's mindset.
An architect's lens.

I'm Shatrughna Kumar, a software architect working across enterprise platforms, Sitecore and modern digital experiences. The Tech Pursuit is where I share practical lessons from designing systems, reviewing code and working with teams.

Connect on LinkedIn ↗