In today’s digital age, customers expect personalization. However, creating truly engaging, dynamic experiences is still a challenge for many brands. Sitecore Stream, is a game-changing platform that enables real-time content delivery, helping companies connect with their audiences on a deeper level and drive tangible business results. Lean how Sitecore Stream transforms personalization, optimizes the customer journey, and drives long-term ROI growth.

The Power of Real-Time Personalization with Sitecore Stream

Real-time personalization goes beyond addressing customers by name; it adapts content dynamically based on user behavior, preferences, and context, delivering precisely what they need in the moment. Sitecore Stream’s capabilities empower brands to create these impactful, in-the-moment connections.

• Sitecore Stream’s real-time features analyze user behavior instantly, allowing brands to adapt content in milliseconds. This dynamic adaptability fosters a unique user experience tailored specifically to each visitor.
• Personalization in real-time resonates on a personal level, encouraging higher engagement rates by delivering relevant content when it matters most.
• Imagine an e-commerce brand using Sitecore Stream to instantly adjust product recommendations based on browsing history and recent purchases, creating a smoother path to conversion.

By embracing Sitecore Stream’s real-time personalization, brands not only meet but exceed customer expectations, by fostering loyalty and setting the stage for improved ROI. When customers feel understood and valued, they’re more likely to return and recommend the brand.

Maximizing ROI Through Enhanced Customer Journeys

Beyond immediate engagement, Sitecore Stream provides a strategic advantage by refining the entire customer journey. From the first interaction to the post-purchase experience, Sitecore Stream enables companies to personalize each touchpoint, creating a seamless and satisfying journey.

• Sitecore Stream maps out user behavior, enabling brands to identify and optimize key journey points, guiding users effortlessly toward conversions.
• Real-time data from Sitecore Stream provides insights into customer preferences and actions, helping companies make data-driven adjustments for continuous journey improvements.
• Improved journeys directly impact conversion rates, average purchase values, and customer lifetime value. With Sitecore Stream’s analytics, brands can continuously refine their approach and maximize ROI.

Future-Proofing Content Delivery for Long-Term ROI Growth

Sitecore Stream is geared to help companies stay agile in a rapidly changing digital landscape. As consumer expectations evolve, brands can rely on Sitecore Stream’s real-time capabilities to continually adapt and deliver personalized experiences, ensuring sustainable growth and ROI over the long term.

• Sitecore Stream’s infrastructure is designed to evolve with emerging trends, making it an essential asset for companies looking to stay competitive.
• By continuously enhancing content delivery, brands keep audiences engaged and loyal, creating a cycle of sustained customer satisfaction and ROI.
• Long-term ROI is not just about immediate returns; it’s about positioning a brand as a leader in personalization. Sitecore Stream provides a strategic edge, empowering brands to anticipate and meet future demands.

In a world where customer expectations are constantly evolving, Sitecore Stream allows brands to meet those expectations and maximize engagement and ROI. From real-time personalization to journey optimization and future-proof adaptability, Sitecore Stream helps brands not just keep up but lead the way in delivering meaningful, impactful experiences.

We expect to see Sitecore Stream empower businesses to position themselves to achieve both immediate and long-term ROI, fostering deeper customer connections and building a future-proof content strategy. I am excited to see where this AI journey unfolds.

Welcome to my recap of Sitecore Symposium 2024! The week continued with numerous insightful sessions, informative workshops, and exciting new announcements. Here are my session notes and takeaways from the final day at Symposium, day three.

Opening Keynote

Opening keynote with Brendan Hunt

The morning kicked off on a high note with a special guest appearance by Brendan Hunt, who plays Coach Beard on Ted Lasso. Though I haven’t watched the show myself—there are simply too many good ones to keep up with —I still found his insights engaging and relevant. He shared valuable lessons that resonate in both work and life, without needing to be star-struck to appreciate them.

• How to make work not suck
  • Connect with co-workers.
  • Surprise your co-workers.
  • Make today different than yesterday.
    • Don’t fall into the trap of the mundane.
  • Be curious, not judgmental.
    • People have lots of things going on that might not be apparent or shared with you.
  • Don’t let the wisdom of age be wasted on you.
    • Use the knowledge that you have gained.
    • This is the opposite of youth is wasted on the young.

CDP and Personalize at Scale

CDP and Personalize at Scale session

Personalization at scale holds immense potential for boosting revenue, and companies that successfully tackle the challenges of scaling personalization will gain a competitive edge. In today’s market, can your business afford not to invest in personalization? While personalization can drive growth, it comes with its own set of challenges—overcoming these will set industry leaders apart from the rest.

• Challenges faced by marketers
  • Creating the right content.
  • Creating enough content.
  • Creating quality content.
  • Technical skills to create content.
  • Understanding what the customer wants/needs.
• Data
  • Ensuring you have the data you need to personalize.
    • Data is often trapped in multiple disconnected systems.
  • Distribution
    • Coordination between channels to ensure a consistent customer experience and messaging.
  • Scaling
    • Content reuse
      • Integrate Sitecore Search to surface existing content.
    • Generative AI
      • Content creation and revision.

XM Cloud Roadmap

The benefit of a SaaS-based product like XM Cloud is that it is being continuously updated. Best of all you get the updates without having to upgrade. XM Cloud has numerous new features coming to the platform.

• Present
  • A/B Testing
  • Marketer’s Dashboard
  • Sitecore Stream content optimization
• Next
  • Updates to Pages
  • Component level personalization
  • Component Library
  • Sitecore Stream brand assistant
• Future
  • Generative AI component builder
  • Embedded Search

Sitecore Lunch

Lunch with friends in the Sitecore community

What a great way to end a great week! An in-person Sitecore lunch started as two tables and then grew to four, six, and eight tables with almost 40 people. This shows the real power of the Sitecore community because although we might work for different companies and be considered “competition”, we can still be friends and discuss Sitecore without boundaries. With my Perficient colleagues, it’s so nice to sit around a physical table with everyone that I normally see every week in little boxes on a Zoom call.

That’s a wrap!

Sitecore Symposium 2024 is over, but there is so much to look forward to in the world of Sitecore over the next year. I’m thrilled about the upcoming changes in CDP, Personalize, and Search with unified tracking, as well as the potential of Sitecore Stream for AI-driven insights, content creation, and brand-aware marketing support. I’m also looking forward to the Sitecore Marketplace, where we can build apps and expand the capabilities of XM Cloud. Feel free to connect with me on LinkedIn. I’d love to chat and hear more about what Sitecore news you are most excited about.

Welcome to my recap of Sitecore Symposium 2024!  Day 2 at Symposium offered incredible insights and valuable information. There was no shortage of engaging sessions and thought-provoking discussions and we are so excited to bring these fresh perspectives back. Here are my session notes and takeaways from day two.

Women in Digital Breakfast

What an inspiring way to start the day! Sitecore and Perficient joined to bring the inaugural Women in Digital Breakfast to life. The morning started with a nice breakfast buffet and there was time to hang out and connect with other attendees. Perficient continued our “Skip the Swag” initiative and left notecards on the tables where each attendee could write and share how cancer has impacted their life. For each attendee, Perficient will make a donation on their behalf to the American Cancer Society. The panel discussion was very well done and the speakers had great insight and takeaways.

• How can men help support women in the workplace?
  • Create space for women.
  • Bring women along on your journey.
  • Stand up for your women colleagues.
  • Be an ally.
• How can we help to eliminate gender roles in future generations?
  • Raise boys and girls with the same standards.
  • Do not force kids into certain roles, hobbies, or toys that play to gender stereotypes.
• Many women left the workforce during the pandemic to support kids and families but now…
  • They are coming back.
  • They are changing careers.
  • They need support.
• How can we support women with families (or anyone with a family really)?
  • Be understanding.
  • Family comes first.
  • Work is a part of life, not your whole life.

Opening Keynote

Eric Stine opened the day with the announcement that Content Hub, XM Cloud, and CDP are all HIPPA compliant! This is a big deal since it allows Sitecore to be able to sign BA agreements with healthcare organizations. In today’s modern world, users expect personalized experiences but this is difficult when it comes to PHI. You cannot change your personal information like you can your credit card if you get hacked. Protecting personal information is important to a brand’s trust.

Experience Awards

The morning continued with the announcement of the Experience Award winners for 2024.  Perficient was pleased to win the Global Sitecore Practice Excellence Award. You can see a full list of all the winners in Sitecore’s official press release. Congratulations to all the winners!

Sitecore Search at Scale

This project included 6 sources, 7000 PDFs, and 44 languages! How do you scale Sitecore Search to a project that large?

• Identify your data
  • What you want to index.
• Analyze the data
  • How can you standardize your data?
• Expose your data
  • Sitecore Search uses a crawler, so it must be able to access your data in order to index it.
• How will Search help your clients?
  • What problem are they trying to solve?
  • What are they looking for?
  • Is the data useful to your clients?
• “Make it like Google”
  • Google has hundreds of developers solely focused on search.
  • Your development team is likely much smaller and has many other tasks to accomplish to launch a site.
  • Your search experience is only as good as the time and money you can devote to it.

Introducing Sitecore Marketplace

More people are moving to XM Cloud and other SaaS products. 82% of users say that an app marketplace is an important factor in choosing a DXP platform. Sitecore is taking that information to heart and creating a new Sitecore Marketplace. This will be a fully supported solution for discovering, enabling, and managing apps, plugins, and extensions.

• This gives developers
  • The tools and technologies to create add-ons for Sitecore products
    • SDKs
    • UI libraries
    • Support and documentation
    • Starter library
  • Support for app versions
  • App visibility
    • Public
    • Private (invite only access)
  • This gives customers
    • The ability to add new features and capabilities to their instance

Sitecore CDP – Unified Tracking

Sitecore’s composable suite of products are becoming easier to connect together. Unified tracking means that you only must integrate one SDK. It also means that each event triggered will persist across all Sitecore products. The first products to use unified tracking will be XM Cloud, CDP, Personalize, and Search.

• Session Tracking
  • A new session end event in CDP that allows you to update the guest profile.
• Profile Sharing
  • The guest profile can be shared across products.
    • Use the guest ID in CDP to find the same user in Search.
  • Audience segments can be shared across products.
    • Search results can be tailored to the audience segment.
  • Cloud SDK
    • One SDK to rule them all.
      • The Cloud SDK will reach feature parity with the Engage SDK.
      • The Cloud SDK will be the primary and best way to integrate

Symposium Party

Sitecore sure knows how to throw a party! We had bus service to downtown Nashville where we had space at four bars on Broadway just for attendees! There was a buffet with all the southern comforts including my favorites: chicken and waffles and shrimp and grits!  To top it off, there were three floors of entertainment and a rooftop with a view of downtown. There was live music, line dancing, drinks, and good times with good friends!  What a great night and great experience at Sitecore Symposium!

I’ve been working with Next.Js for a quite a while and have been watching its development with interest all this time. Last week I was happy attended Next.js Conf in San Francisco. Perficient was proud to sponsor the event, allowing us to showcase our Sitecore Practice alongside my colleague David Lewis from the Optimizely Practice.

Vercel released new version 15 of Next.js framework. That was truly innovative day and I’d like to share my takeaways from the event about this new version.

Vercel seriously worked on mistakes

In the past, the Next.js team made some questionable decisions, such as rushing releases and maintaining rigid opinions despite community feedback. This included changes like rewriting the fetch API, implementing hard caching, and introducing numerous bugs, among other issues, while once again overlooking community requests. It took nearly a year for the team to recognize that these approaches were ineffective and to begin addressing the underlying problems. With the release of version 15, there is finally a sense that the framework is truly meeting the needs of its community, much as it has successfully done in previous iterations.

React 19

We are currently facing an unusual situation. Over six months have passed since the release candidate of React.js was introduced, yet the stable version has not been published. This delay directly impacts Next.js, as the two frameworks are closely intertwined. As a result, Next.js is currently utilizing the release candidate version of React.js, but this is only partially accurate. In reality, Next.js employs two different React.js configurations:

• React.js 19 Canary for the App Router
• React.js 18 for the Pages Router

Interestingly, there was an initial plan to integrate the React.js 19 version for the Pages Router as well. However, these changes were later rolled back. Full support for React.js version 19 is expected once the stable release is officially launched.

Form component

This next.js innovation is in fact already familiar form from react-dom, but with some improvements. You benefit from Next.Js implementation primarily in cases when a successful form submission involves a transition to another page. In that case, the loading.tsx and layout.tsx abstractions for the following page will get preloaded.

import Form from 'next/form'
 
export default function Page() {
  return (
    <Form action="/search">
      {/* On submission, the input value will be appended to 
          the URL, e.g. /search?query=abc */}
      <input name="query" />
      <button type="submit">Submit</button>
    </Form>
  )
}

Developer Experience (DX)

When discussing Next.js, the developer experience (DX) is impossible to overlook. Beyond the typical “Faster, Higher, Stronger” claims, Next.js has introduced several meaningful improvements that significantly enhance DX:

1. Long-awaited support for ESlint v9. Next.js never supported ESlint v9. This is despite the fact that both eslint (v8) and some of its own dependencies were already marked as deprecated. Because of that developers were essentially forced to keep deprecated packages.
2. The error interface in next.js – which is already clear and convenient – was slightly improved:
   1. Added a button to copy the call stack;
   2. Added the ability to open the source of the error in the editor on a specific line.
3. Added Static Indicator – an element in the corner of the page showing that the page is built in static mode. The pre-built page indicator has been with us for years so it was slightly updated and adapted for App Router.
4. Also added a directory with debug information – .next/diagnostics. That’s where one can find information about the build process and all errors that occur (sometimes helps to parse problems).

Versioning the documentation

One particularly valuable enhancement is the ability to access different versions of the documentation. But why is this so crucial for the developer experience?

Updating Next.js to accommodate major changes can be a challenging and time-consuming task. As a result, older versions like Next.js 12 and 13 remain widely used, with over 2 million and 4 million monthly downloads respectively. Developers working with these versions need documentation that is specific to their setup, as the latest documentation may include significant changes that are not compatible with their projects. By providing versioned documentation, Next.js ensures that developers have the reliable resources they need to maintain and update their applications

Turbopack

Probably the biggest news:

• Turbopack is now fully complete for development mode! “100% of existing tests ran with no errors for Turbopack”
• Now the turbo team is working on the production version, progressively going through the tests and covering them all (currently about 96%)

Turbopack introduces a range of new features that enhance its functionality and performance:

1. Setting a memory limit for a Turbopack build;
2. Tree Shaking (in other words that is removal of the unused code):

3. const nextConfig = {
     experimental: {
       turbo: {
         treeShaking: true,
         memoryLimit: 1024 * 1024 * 512 // bytes (512MB)
       },
     },
   }

   These turbopack change alone reduced memory usage by 25-30% and speeded up heavy page assembly by 30-50%.”

4. Fixed significant issues with styles. In version 14, there were often situations when the styles were broken in order during navigation, and because of this, style A became higher than style B, then lower. This changed their priority and, accordingly, the elements looked different.
5. The next long-awaited improvement. Now you can write the configuration in TypeScript, and the file correspondingly would be next.config.ts:

   import type { NextConfig } from 'next';
    
   const nextConfig: NextConfig = {
     /* here goes you config */
   };
    
   export default nextConfig;

   Same strongly-typed syntax as usual, but very nice to have, finally!

6. Another interesting innovation is retrying a failed page generation before actually failing the build for static pages. If the page fails the assembly for the connectivity issues, it will try it again:

   const nextConfig = {
     experimental: {
       staticGenerationRetryCount: 3,
     },
   }

Framework API changes

Updating Next.js often involves some of the most challenging aspects, and version 15 is no exception with its critical enhancements.

One significant change in version 15 is the transition of several framework APIs to asynchronous operations. This shift particularly affects the core framework-centric abstractions, including:

• cookies,
• headers,
• params and
• searchParams (also called Dynamic APIs).

import { cookies } from 'next/headers';
 
export async function AdminPanel() {
  const cookieStore = await cookies();
  const token = cookieStore.get('token');
  // ...
}

The changes are big indeed, but the Next.js team suggests one could update to the new APIs automatically by calling their codemod:

npx @next/codemod@canary next-async-request-api .

Caching

In my opinion, that is where the most important changes have happened. And the most important news is that Caching is now disabled by default!

Let’s take a look on what’s changed:

• Actually, fetch now uses the no-store value by default instead of force-cache;
• API routes use force-dynamic mode by default (previously it was force-static by default);
• Caching in the client router has also been disabled. Previously, if a client visited a page within the path, it was cached on the client and remained in this state until the page reload. Now the current page will be loaded each time. This functionality can be altered via next.config.js:

  const nextConfig = {
    experimental: {
      staleTimes: {
        dynamic: 30 // defaults to 0
      },
    },
  }

• Moreover, even if client caching is enabled, it most likely will be updated at the correct time. Namely, if the enabled page cache on the server expires.
• Server components are now cached in development mode. Due to this, updates in development are faster.
• Following the above, one can reset the cache by just reloading a page or can also completely disable the functionality via next.config.js:

  const nextConfig = {
    experimental: {
      serverComponentsHmrCache: false, // defaults to true
    },
  }

• You can control the “Cache-Control” header which was previously always overwritten with the internal values ​​of next.js. This caused artifacts with caching via CDN;
•  next/dynamic caches modules for reuse, rather than loading again each time;

Partial Prerendering (PPR)

This could be the main teaser of the release. PPR is a page assembly mode, in which Next.Js prerenders and caches as much of the route as possible,. while some individual elements are built on each request. In this case, the pre-assembled part is immediately sent to the client, and the remaining are loaded dynamically.

PPR diagram from the official documentation

The feature existed already six months ago in the release candidate as an experimental API. Previously PPR was enabled for the entire project, but since now it one can enable it for each segment (layout or page):

export const experimental_ppr = true

Another change is Partial Fallback Prerendering (PFPR). Due to this improvement, the pre-assembled part is immediately sent to the client, and the rest are loaded dynamically. At this time, a callback component is shown in place of the dynamic elements.

import { Suspense } from "react"
import { StaticComponent, DynamicComponent } from "@/app/ui"
 
export const experimental_ppr = true
 
export default function Page() {
  return {
     <>
         <StaticComponent />
         <Suspense fallback={...}>
             <DynamicComponent />
         </Suspense>
     </>
  };
}

Instrumentation

Instrumentation comes as a stable API. The instrumentation file allows users to affect Next.js server lifecycle. Works universally with all Pages Router and App Router segments.

Currently, instrumentation supports hooks:

• register – called once when initializing the next.js server. Can be used for integration with monitoring libraries (OpenTelemetry, datalog) or for specific project tasks.
• onRequestError – a new hook called on all server errors. Can be used for integration with error tracking libraries (Sentry).

Interceptor

Interceptor is route-level middleware. It feels as something like a full-fledged existing middleware, but, unlike the one:

• Can work in node.js runtime;
• Works on the server, therefore has access to the environment and a single cache;
• Can be added multiple times and is nesting inherited (like middleware worked when it was in beta);
• Works, among other things, for server functions.

In this case, when creating an interceptor file, all pages underneath the tree become dynamic.

• If we keep Vercel in mind, now middleware will be effective as a primary simple check at the CDN level (so that it could immediately return redirects if the request is not allowed), and interceptors will work on the server, doing full checks and complex operations.
• For the self-host, apparently, such a division will be less effective since both abstractions work on the server. Perhaps it will be enough just to use only interceptor.

Welcome v0 – Vercel’s new Generative UI

Last but not least, Next.js introduces Generative UI (v0), a groundbreaking feature that combines the best practices of frontend development with the full potential of generative AI. Currently in Beta, I had the opportunity to experience Generative UI firsthand at the event. I was thrilled to see how powerful and intuitive it is—from the very first prompt, it successfully generated the configuration for Sitecore!

I am thrilled to conclude that our toolbelt has been enriched with new, practical tools that enable us to deliver exceptional solutions effortlessly, eliminating the need to reinvent the wheel.

Well done, Vercel! Thanks everyone building this wonderful ecosystem:

Welcome to my recap of day one at Sitecore Symposium 2024! There was no shortage of inspiring sessions, key takeaways, and exciting announcements from day one.

Opening Keynote

The opening keynote by Sitecore executives was an excellent kickoff to Symposium, reinforcing their commitment to being a trusted partner. They emphasized their focus on core strengths and want people to have a choice, whether it be XM Cloud, XM, or XP. Sitecore is determined to stay ahead of the market through innovation and they made several exciting announcements about the direction they’ll take in the coming year. It’s an exciting time to be working with Sitecore!

Introducing Sitecore Stream! Sitecore Stream is the new brand-aware AI generative copilot that will work with marketers as they try to do more with less.

• Will be integrated across all DXP products
• Shortened time to value.
• Keep marketing materials consistent.
• Help create new campaigns.
• Balance strategy with technology.

It really is an impressive tool and I, along with many others in the Sitecore community, can’t wait to see it in action. You really do have to see it to believe it.

Accessibility and the Impact on your Business

Accessibility is more important than ever, yet it’s often treated as an afterthought, typically addressed at the end of projects when it should be prioritized from the start. It’s not just about checking a box or a one-and-done effort—accessibility affects everyone and can benefit anyone. Good website design enhances the user experience for all, not just those with disabilities.

• Why is accessibility important?
  • Regulatory
  • Legal
  • Financial
  • Equality
  • Doing the right thing
• ADA lawsuits:
  • The number of lawsuits is rising over time.
    • In 2018 there were 2,000+ Lawsuits.
    • In 2023 there were 4,000+ lawsuits.
  • According to the ADA, 72% of lawsuits were against companies with less than 50 million in revenue.
    • Small companies are at just as high of risk as large companies.
  • Statistics:
    • According to the CDC, 28.7% of people have a disability.
    • UNC School of Medicine found that 71% of web users with a disability will leave a site if it is not accessible.
    • This equates to a potential 20% loss of revenue.
      • Can you afford to not be accessible and lose this amount of business?
    • Doing the right thing:
      • It can increase your reputation.
      • It can generate loyalty.
      • It’s a key differentiator.
      • It’s a marketing opportunity.
      • It makes the world better for everyone.

Is AI Bias the New Elephant in the Room?

Bias is an unfavored weight towards one group of people. How does this affect generative AI? Test it yourself: create an image without specifying details like age, gender, or race. What results do you see? Chances are, the image lacks cultural diversity, and representation of people with disabilities, or older individuals. It may also reflect assumptions about gender roles based on job titles.

• How AI bias happens:
  • Algorithmic bias during the development of the model
  • Data bias in the model training phase
  • Interaction bias when the AI learns from biased human interactions
• What is the impact of bias?
  • Legal and ethical consequences
  • Lost revenue
  • Erases diversity
• How can we reduce this bias?
  • Add diverse perspectives when building the algorithms
  • Train people to identify bias in generative AI results
  • Reward people doing good work

Sitecore Search Product Roadmap

Sitecore Search is continuously evolving like many other SaaS products. Take a look at the future of Sitecore Search.

• Current
  • Commerce product grouping
    • Group similar products on product or size variations
  • Commerce rules
    • Bury low or out-of-stock items
  • CDP
    • Audience segment support
  • Next
    • Unified tracking.
      • Tracking IDs will work across many of Sitecore’s composable products
    • XM cloud content indexing
      • Push changes directly into Search
    • Order cloud integration
    • Generative AI Q&A for search prompt
    • More accurate recommendations
  • Future
    • Refined UX
    • Simplified indexing connectors
    • Copy rules between instances
    • Exposed search analytics
    • Conversational search
    • Generative AI metadata

Sitecore’s Experience Editor aids Content Author/Editor in creating pages effortlessly, however, it can be bewildering at the same time for authors who are creating new pages with minimal knowledge about the website’s placeholders and renderings.

Experience Editor by default does not provide details about which rendering is present and what data source it is using, you may have to check rendering properties to get some of this information.

Adding Rendering Wrappers in Experience editor is a way to help Content Authors to build and edit pages more efficiently by highlighting each rendering’s hierarchical details making page structure distinguishable and less confusing if multiple child components are present.

Lets see how it can be done in Sitecore and Sitecore JSS.

To achieve this, we need to create a processor that implements RenderRenderingProcessor and patch it after AddWrapper Pipeline.

Below is snippet of Class extending RenderRenderingProcessor:

public class AddPageEditorMetadata : RenderRenderingProcessor
   {
       private readonly List<Regex> _parentNameMatcher = new List<Regex>();
       private readonly List<Regex> _itemNameMatcher = new List<Regex>();

       // checks the immediate parent folder of the rendering against each pattern in the list.  If any pattern matches, the rendering is wrapped.
       public void AddParentNamePattern(string pattern)
       {
           _parentNameMatcher.Add(new Regex(pattern));
       }
       
       //checks the name of the rendering itself against each regular expression in the list.  If any pattern is matched, the rendering is wrapped.
       public void AddItemNamePattern(string pattern)
       {
           _itemNameMatcher.Add(new Regex(pattern));
       }

       public override void Process(RenderRenderingArgs args)
       {
           if (args.Rendered || Context.Site == null || !Context.PageMode.IsExperienceEditorEditing)
           {
               return;
           }

           RenderingContext renderingContext = RenderingContext.CurrentOrNull;

           Rendering rendering = renderingContext?.Rendering;

           // rendering.RenderingItem is null when presentation details points to a rendering that is no longer in Sitecore 
           // RenderingXml property is only set on renderings that were bound to a placeholder via presentation details
           if (rendering?.RenderingItem == null || rendering.Properties["RenderingXml"].IsWhiteSpaceOrNull())
           {
               return;
           }

           DoProcess(rendering, args);
       }

       protected virtual void DoProcess(Rendering rendering, RenderRenderingArgs args)
       {
           Assert.ArgumentCondition(args.Disposables.Count > 0, "args.Disposables", "expect to be more than zero");
           
           RenderingItem renderingItem = rendering.RenderingItem;

           // do we need to wrap component with meta data to make it visible within EE, usually it is necessary for a structural component. 
           bool isMetaReq = _parentNameMatcher.Count > 0 && _parentNameMatcher.Any(x => x.IsMatch(renderingItem.InnerItem.Parent.Name))
                            || _itemNameMatcher.Count > 0 && _itemNameMatcher.Any(x => x.IsMatch(renderingItem.InnerItem.Name));

           int index = args.Disposables.FindIndex(x => x.GetType() == typeof(Wrapper));
           if (index < 0)
           {
               Log.Warn($"Cannot find rendering chrome wrapper and will not insert metadata wrapper for [{rendering}]", this);
               return;
           }

           IMarker marker = isMetaReq ? new MetadataMarker(rendering, string.Empty) as IMarker : null;

           if (marker == null) return;
           args.Disposables.Insert(index, new Wrapper(args.Writer, marker));
       }

       
   }

Then create a class that implements IMarker and actually insert the HTML markup in wrapper to display the details of rendering.

public class MetadataMarker : IMarker
        {
            private readonly Rendering _rendering;
            private readonly string _xprIconHtml;

            public MetadataMarker(Rendering rendering, string xprIconHtml)
            {
                Assert.ArgumentNotNull(rendering, "_rendering");

                _rendering = rendering;
                _xprIconHtml = xprIconHtml;
            }

            public virtual string GetStart()
            {
                var result = new StringBuilder();

                RenderingItem renderingItem = _rendering.RenderingItem;

                string folderName = renderingItem.InnerItem.Parent.Name;
                string componentName = renderingItem.DisplayName;
                var datasourceIcon = string.Empty;
                if (!string.IsNullOrEmpty(_rendering.DataSource))
                {
                    datasourceIcon = $"<span class=\"glyphicon glyphicon-list-alt\"></span>{(_rendering.Item != null ? _rendering.Item.DisplayName : string.Empty)}";
                }

                var title = $"<span class=\"panel-title\"><span>{folderName}:</span>{componentName} {datasourceIcon} {_xprIconHtml}</span>";

                result.AppendFormat("{0}", title);
                return result.ToString();
            }
        }

Finally, patch the new processors after Sitecore.Mvc.ExperienceEditor.Pipelines.Response.RenderRendering.AddWrapper

<mvc.renderRendering>
                <processor
                    patch:after="processor[@type='Sitecore.Mvc.ExperienceEditor.Pipelines.Response.RenderRendering.AddWrapper, Sitecore.Mvc.ExperienceEditor']"
                    type=".............AddPageEditorMetadata, ProjectName">

                    <parentNamePatterns hint="list:AddParentNamePattern">
                        <pattern>(Product)|(Page Content)|(Structure)</pattern>
                    </parentNamePatterns>

                    <itemNamePatterns hint="list:AddItemNamePattern">
                        <pattern>(Full Width Container)|(Three Column Container)|(Three Column Large Middle)</pattern>
                    </itemNamePatterns>

                </processor>
            </mvc.renderRendering>

It renders something like below:

I hope you find this piece of information helpful.

Sitecore Symposium 2024 is Underway!

A conference like Sitecore Symposium is a great way to make a mini vacation out of your work travels. I arrived on Sunday and explored the city of Nashville. Did you know that Nashville is home to a full-scale replica of the Parthenon? It was built in 1897 as part of the Tennessee Centennial Exposition. Today, it’s the only remaining building from the exposition and has since been turned into a museum. The museum contains the largest indoor statue in the Western Hemisphere, the goddess Athena in full gold leaf standing at 41ft tall.

Symposium is being hosted at the Gaylord Opryland Resort. This is my first time here and the hotel is beautiful. The atrium is covered in glass and has lush green gardens and walking paths with waterfalls. You can even take a boat ride through the interior.

For me, the best part about these conferences is seeing people face-to-face! Most of us work remotely and are only able to see these people on phone calls and little boxes on our screen in a grid on a zoom call. It’s great to see people in person, face-to-face because technology can’t replicate that experience.

Exploring Nashville

The conference schedule fills up quickly, so having time beforehand to hang out with friends is great. Chet Potvin  organized a walking food tour of Nashville on Sunday night. We started out at a rooftop bar with a great view of downtown Nashville. The guide shared some great stories about Nashville history, culture, music, and food. We had four stops, which included Nashville barbecue and the famous Nashville hot chicken.

MVP Summit

Monday was the MVP Summit. This was my first time attending. While I can’t share any of the information from the sessions, I can say it was a great experience. We got a sneak peek of inside information and got to interact with the Sitecore product teams and executives. We had interactive conversations and it’s great knowing that the team at Sitecore really listens to our feedback. As MVPs, we are really able to impact the products.

MVP Party

After a full day of sessions, we were treated to an MVP party at Dave and Buster’s. Sitecore booked the entire venue just for us. We had great food and drink, unlimited gaming, and karaoke. It was a great time to hang out with old friends and make new friends.

Tiffany, Josh, and I challenged Dave O’flanagan to a race of Mario Kart! MJ is quite the instigator and isn’t afraid to let loose and encourage others to do the same. We did a great version of Ice Ice Baby. And in case you’re curious, yes, we know all the words. The night ended with 15 people singing Closing Time. But we weren’t done yet. On the walk back to the hotel, we gave our best acapella version of Sweet Caroline. It was so good so good so good! What a fun night! It’s the reward for a full year’s worth of hard work to achieve MVP status.

Looking Ahead to Symposium

I’m looking forward to seeing what more Sitecore Symposium has to offer. It promises to be full of innovation, collaboration, fresh insights, and informative sessions. If you’re attending Sitecore Symposium, stop by our Perficient booth!

Intro

In this post, I’ll cover three tips developers should consider when deploying a new headless site to XM Cloud. Having recently added a new headless site to an existing solution, I ran into a few issues. I hope to save others from similar headaches in the future (mostly myself ). If you’ve added a new headless site to your XM Cloud solution recently and are having trouble getting the site to appear and function properly, please read on .

1. Verify the New Site’s Start Item

After deploying your new site, if you notice that the site isn’t appearing on the Sites landing page in XM Cloud (https://xmapps.sitecorecloud.io/?tab=tools&tenantName=<tentant_name>&organization=<organization>), double-check that the site’s Start item field is set. This field can be found on the site’s Site Grouping item whose path is (usually) as follows:

/sitecore/content/<site_collection>/<site>/Settings/Site Grouping/<site>

Moreover, make sure that the referenced item is physically present in the content tree. If the Start item isn’t present, the site won’t appear in XM Cloud.

Verify that the Start item is set and points to an actual page.

In my particular case, I had initially misconfigured serialization for the new site and inadvertently excluded the new site’s Home item. The Start item field was set, but it didn’t point to anything in the target environment, so my new site wasn’t showing up in XM Cloud .

2. Verify the Rendering Host Items

If your new site is appearing in XM Cloud but you can’t open any pages in Experience Editor or Preview, something could be wonky with the rendering host items.

Every XM Cloud solution includes an xmcloud.build.json file in the root directory. This is the XM Cloud build configuration file; it controls how XM Cloud builds and deploys the solution. Included in this file is a list of the rendering hosts that XM Cloud should provision and spin up as part of a deployment. Rendering hosts (also sometimes called “editing hosts” in the context of a CM) are necessary to drive Sitecore’s Experience Editor and Preview functionality. The xmcloud.build.json file is pretty important and useful; for more information on this file and what it can do, please refer to the official documentation here: https://doc.sitecore.com/xmc/en/developers/xm-cloud/the-xm-cloud-build-configuration.html.

There should be an entry in the renderingHosts property of the xmcloud.build.json file for every separate headless application in your solution. Note, however, that it is possible to run multiple headless sites with a single head application using the JSS multisite add-on. For more information on the pros and cons of either approach, check out this Sitecore developer article: https://developers.sitecore.com/learn/accelerate/xm-cloud/pre-development/project-architecture/multisite#web-application.

For the purposes of this tip, assume that there are two headless sites, each with their own headless Next.js application running different versions of Node (which also implies the need for two separate rendering hosts–one rendering host can’t run multiple versions of Node/Next.js). Let’s say the xmcloud.build.json file looks something like this:

{
    "renderingHosts": {
        "mysite1": {
            "path": "./src/rendering-mysite1",
            "nodeVersion": "16.15.1",
            "jssDeploymentSecret":"<redacted>",
            "enabled": true,
            "type": "sxa",
            "lintCommand": "lint",
            "startCommand": "start:production"
        },
        "mysite2": {
          "path": "./src/rendering-mysite2",
          "nodeVersion": "20.14.0",
          "jssDeploymentSecret":"<redacted>",
          "enabled": true,
          "type": "sxa",
          "lintCommand": "lint",
          "startCommand": "start:production"
      }
    },
    ...

When XM Cloud runs a deployment, it reads the xmcloud.build.json file, iterates through the renderingHosts property, and provisions the relevant containers behind the scenes. When the deployment completes, the rendering host items in the content tree are created and/or updated under this folder:

/sitecore/system/Settings/Services/Rendering Hosts

The rendering host items in this folder map to the rendering hosts enumerated in the xmcloud.build.json file.

One interesting thing to note is that, regardless of the name of the first rendering host the xmcloud.build.json file (e.g., mysite1 in the example above), the first rendering host in the xmcloud.build.json file will always be created in the Sitecore content tree with a name of Default. The N + 1 rendering hosts will have the names listed in the xmcloud.build.json file. For example (again, assuming the xmcloud.build.json file, above ), the post-deployment rendering hosts in the target XM Cloud environment would look like this:

The resulting rendering host items from an XM Cloud deployment.

Once XM Cloud creates these items, it sets them to protected in the content tree–these items should not be modified outside of the XM Cloud deployment process.

If, for whatever reason, you’ve serialized these items and have manually overridden the items (either by making manual changes or by installing a content package), you can get into a situation where the changes and updates during XM Cloud deployments on these items are ignored because Sitecore is looking at the overridden items. This will remain an issue until the overridden serialized items are either cleaned up using the Sitecore CLI itemres cleanup command (reference: https://doc.sitecore.com/xmc/en/developers/xm-cloud/the-cli-itemres-command.html#the-cleanup-subcommand) or the overridden items are simply deleted (to be restored on the next deployment).

The TL;DR for this tip: do not serialize rendering host items corresponding to entries in the renderingHosts property in the xmcloud.build.json file–XM cloud manages these items, so you don’t have to.

3. Set the Name and Description for the Site Collection

The XM Cloud Sites landing page has been updated recently but, in the past, the name of the site collection to which a site belonged would sometimes be presented as “N/A”:

A site’s Collection label reading “N/A”.

It turns out that there’s a field section on site collection items that lets developers set the Name and Description for the site collection. Admittedly, initially, I was just annoyed with the “N/A” and wanted a way to set the site collection name. However, it’s generally a good idea to name and describe your site collections anyway, especially if there are (or will be) many of them. To set the Name and Description fields on a site collection item, navigate to the site collection item in the content tree and drill down to the Metadata field section to provide values for these fields:

Setting the Name and Description of a site collection.

Be sure to serialize any updates to these items using the Sitecore CLI ser pull command (reference: https://doc.sitecore.com/xmc/en/developers/xm-cloud/the-cli-serialization-command.html#the-pull-subcommand). Site collection items are developer-controlled and should be consistent between environments.

Now, in the XM Cloud Sites interface (and possibly elsewhere in the future), it’ll be easier to differentiate between site collections and determine the purpose of a given site collection.

Thanks for the read!

Perficient is proud to announce that we have been recognized as Sitecore’s 2024 Practice Excellence Award Global Winner. This award recognizes Perficient for being a solution partner who is successful in building a business around their Sitecore practice, highlighting our power to adapt and grow.

“We are honored to receive the Sitecore Practice Excellence Award, a testament to our unwavering commitment to innovation, growth and teamwork,” said Art Quinn, General Manager, DX Platform Solutions. “This achievement underscores our ability to adapt and thrive in an ever-evolving digital landscape, empowering our clients with cutting-edge solutions and driving success through our Sitecore practice. Congrats to our entire Sitecore team on this well-deserved award.”

In addition, Sitecore has recognized Perficient and three of our customers as Sitecore Experience Award finalists. Finalists’ selection is awarded to customers and partners who have created standout digital experiences and demonstrated impressive business outcomes. Congratulations to Daltile for being a finalist in the Best Experience Transformation category and Emory Healthcare and ONEOK in the Best Content Management Modernization category. Category winners will be announced in October.

Sitecore Symposium

We cannot wait to celebrate and connect with our customers and friends at Sitecore Symposium next month. This is Sitecore’s biggest event of the year and it promises to be full of inspiring stories, innovation-driven sessions, and ample networking opportunities. Stop by our booth to talk with our experts and learn more about our Sitecore Symposium presence here.

Our Sitecore Practice

An award-winning Sitecore Platinum Implementation partner, Perficient has designed, implemented, and delivered many enterprise-level sites powered by the Sitecore Experience Platform. Our team of Sitecore experts, including several MVPs, and more than 250 certified Sitecore developers understand how to get the most out of Sitecore’s versatile digital experience platform to create highly effective and personalized experiences for our clients and their end customers.

Historically when performing content migration with Sitecore we used to deal with database backups. In a modern SaaS world, we do not have the luxury of neither managing cloud database backups, nor the corresponding UI for doing this. Therefore, we must find an alternative approach.

Technical Challenge

Let’s assume we have a legacy Sitecore website, in my case that was XP 9.3 and we’ve been provided with only master database backup having all the content. The objective is to perform content migration from this master database into a new and shiny XM Cloud environment(s).

Without having direct access to the cloud, we can only operate locally. In theory, there could be a few potential ways of doing this:

1. Set up a legacy XP of the desired version with the legacy content database already attached/restored to it. Then try to attach (or restore) a vanilla XM Cloud database to a local SQL Server as a recipient database in order to perform content migration into it.  Unfortunately, the given approach would not work since SQL Server version incompatibility between XM Cloud and XP 9.3. Even if that was possible, running XP 9.3 with the XM Cloud database won’t work as Xз 9.3 neither knows about XM Cloud schema nor is capable of handling Items as Resource required feature which was invented later in XP 10.1. Therefore – this option is not possible.

2. Can we go the other way around by using the old database along with XM Cloud? This is not documented, but let’s assess it:

   1. Definitely won’t work in the cloud since we’re not given any control of DBs and their maintenance or backups.

   2. In a local environment, XM Cloud only works in Docker containers and it is not possible to use it with an external SQL Server where we have a legacy database. But what if we try to plug that legacy database inside of the local SQL Container? Sadly, there are no documented ways of achieving that.

3. Keep two independent instances side by side (legacy XP and XM Cloud in containers) and use an external tool to connect both of them in order to migrate the content. In theory that is possible but carries on few drawbacks.
   1. The tool of choice is Razl, but this tool is not free, requires a paid license, and does not have a free trial to ever test this out.
   2. Connecting to a containerized environment may not be easy and require some additional preps
   3. You may need to have a high-spec computer (or at least two mid-level machines connected to the same network) to have both instances running side by side.

After some consideration, the second approach seems to be reasonable to try so let’s give it a chance and conduct a PoC.

Proof of Concept: local XM Cloud with external content database

Utilize the second approach we’re going to try attaching the given external legacy database to XM Cloud running in a local containerized setup. That will allow using a built-in UI for mass-migrating the content between the databases (as pictured below) along with the Sitecore PowerShell script for finalizing and fine-tuning the migrated content.

Step 1: Ensurу SQL Server port is externally exposed

We are connecting the external  SQL Server Management studio through a port of the SQL Server container that is exposed externally in order to make it possible. Luckily, that has been done for us already, just make sure docker-compose has:

    ports:
      - "14330:1433"

Step 2: Spin up an XM Cloud containers and confirm XM Cloud works fine for you

Nothing extraordinary here, as easy as running .\init.ps1 followed by .\up.ps1.

Step 3: Connect SQL Management Studio to SQL Server running in a container.

After you sound up containers, run SQL Management Studio and connect to SQL Server running in SQL container through an exposed port 14330, as we did at step 1:

Step 4: Restore the legacy database

If you have a Data-Tier “backpack” file you may want to do an extra step and convert it into a binary backup for that particular version used by XMCloud before restoring. This step is optional, but in case you want to restore the backup more than once (which is likely to happen), it would make sense to take a binary backup as soon as you restore the data-tier “backpack” first time ever. Data-tier backups process much slower than binaries, so that will definitely save time in the future.

Once connected, let’s enable contained database authentication. This step is mandatory, otherwise, that would not be possible to restore a database:

EXEC sys.sp_configure N'contained database authentication', N'1'
go
exec ('RECONFIGURE WITH OVERRIDE')
go

One more challenge ahead: when performing backup and restore operations, SQL Server shows up a path local to the server engine, and not the host machine. That means, our backup should exist “inside” of SQL container. Luckily, w have this also covered. Make sure docker-compose.override.yml contains:

  mssql:
    volumes:
      - type: bind
        source: .\docker\data\sql
        target: c:\data

That means, one can locate legacy database backups into .\docker\data\sql folder of a host machine and it will magically appear within C:\datafolder when using SQL Management Studio database backup restore tool which you can perform now.

Important! Restore legacy database using the “magic name” in a format Sitecore.<DB_NAME_SUFFIX>, further down below I will be using the value RR as DB_NAME_SUFFIX.

Once got restored database in SQL Server Management Studio under the name Sitecore.RR we need to plug this database to the system. There is a naming convention hidden from our eyes within CM containers.

Step 5: Configure connection strings

Unlike in XM/XP – there is no documented way to plug an external database. The way connection strings are mapped to the actual system is cumbersome, it uses some “magic” hidden within the container itself and obfuscated from our eyes. It only tool to reach it experimental way. Here are the steps to reproduce:

• Add environmental variable to docker-compose record for CM:

  Sitecore_ConnectionStrings_RR: Data Source=${SQL_SERVER};Initial Catalog=${SQL_DATABASE_PREFIX}.RR;User ID=${SQL_SA_LOGIN};Password=${SQL_SA_PASSWORD}

• Add new connection string record. To do so you’ll need to create a connection strings file within your customization project as .\src\platform\<SITENAME>\App_Config\ConnectionStrings.config with the content of the connection strings file from CM container with the addition of a new string:

  <add name="rr" connectionString="user id=user;password=password;Data Source=(server);Database=Sitecore_RR" />

Please note the difference in the suffix format of both above records, that is totally fine. CM container still processes that correctly.

Step 6: Reinstantiating CM container

Simply restarting a CM container is not sufficient. You must remove it and re-create it, just killing/stopping is not sufficient.

For example, the below command will work for that purpose:

docker-compose restart cm

… not will this one:

docker-compose kill cm

The reason is that CM will not update environmental variables from docker-compose file upon restart. Do this instead:

docker-compose kill cm
docker-compose rm cm --force
docker-compose up cm -d

<?xml version="1.0" encoding="UTF-8"?>
<configuration xmlns:patch="www.sitecore.net/.../">
    <sitecore>
        <eventing defaultProvider="sitecore">
            <eventQueueProvider>
                <eventQueue name="rr" patch:after="evertQueue[@name='web']" type="Sitecore.Data.Eventing.$(database)EventQueue, Sitecore.Kernel">
                    <param ref="dataApis/dataApi[@name='$(database)']" param1="$(name)" />
                    <param ref="PropertyStoreProvider/store[@name='$(name)']" />
                </eventQueue>
            </eventQueueProvider>
        </eventing>
        <PropertyStoreProvider>
            <store name="rr" patch:after="store[@name='master']" prefix="rr" getValueWithoutPrefix="true" singleInstance="true" type="Sitecore.Data.Properties.$(database)PropertyStore, Sitecore.Kernel">
                <param ref="dataApis/dataApi[@name='$(database)']" param1="$(name)" />
                <param resolve="true" type="Sitecore.Abstractions.BaseEventManager, Sitecore.Kernel" />
                <param resolve="true" type="Sitecore.Abstractions.BaseCacheManager, Sitecore.Kernel" />
            </store>
        </PropertyStoreProvider>
        <databases>
            <database id="rr" patch:after="database[@id='master']" singleInstance="true" type="Sitecore.Data.DefaultDatabase, Sitecore.Kernel">
                <param desc="name">$(id)</param>
                <icon>Images/database_master.png</icon>
                <securityEnabled>true</securityEnabled>
                <dataProviders hint="list:AddDataProvider">
                    <dataProvider ref="dataProviders/main" param1="$(id)">
                        <disableGroup>publishing</disableGroup>
                        <prefetch hint="raw:AddPrefetch">
                            <sc.include file="/App_Config/Prefetch/Common.config" />
                            <sc.include file="/App_Config/Prefetch/Webdb.config" />
                        </prefetch>
                    </dataProvider>
                </dataProviders>
                <!-- <proxiesEnabled>false</proxiesEnabled> -->
                <archives hint="raw:AddArchive">
                    <archive name="archive" />
                    <archive name="recyclebin" />
                </archives>
                <cacheSizes hint="setting">
                    <data>100MB</data>
                    <items>50MB</items>
                    <paths>2500KB</paths>
                    <itempaths>50MB</itempaths>
                    <standardValues>2500KB</standardValues>
                </cacheSizes>
            </database>
        </databases>
    </sitecore>
</configuration>

<?xml version="1.0" encoding="utf-8"?>
<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/" xmlns:role="http://www.sitecore.net/xmlconfig/role/" xmlns:set="http://www.sitecore.net/xmlconfig/set/">
  <sitecore role:require="XMCloud">
    <powershell>
      <userAccountControl>
        <tokens><token name="Default"  elevationAction="Block"/>
              <token name="Console" expiration="00:55:00" elevationAction="Allow" patch:instead="*[@name='Console']"/>
              <token name="ISE" expiration="00:55:00" elevationAction="Allow" patch:instead="*[@name='ISE']"/>
              <token name="ItemSave" expiration="00:55:00" elevationAction="Allow" patch:instead="*[@name='ItemSave']"/>
            </tokens>
      </userAccountControl>
    </powershell>
  </sitecore>
</configuration>

The Result

Nashville here we come!

Sitecore Symposium is just around the corner and it promises to be one of the most impactful events of the year. Whether you’re a Symposium pro or a first-timer, this conference offers unparalleled opportunities to learn, connect, and grow. Here’s everything you need to know about Sitecore Symposium 2024 and what to expect from team Perficient.

What is Sitecore Symposium?

Sitecore Symposium is Sitecore’s biggest event of the year. This year, the conference will take place October 15-18 at the Gaylord Resort and Convention Center in Nashville, Tennessee. Thousands of brands, marketers, technologists, and digital visionaries come together for three days of top-notch networking, inspiring success stories, innovation-driven sessions, and more.

Perficient’s Presence at Symposium 2024  

Perficient is thrilled to be a sponsor at Sitecore Symposium 2024. Our team is ecstatic to meet you and discuss your Sitecore needs.

While at Symposium, we invite you to stop by our booth and donate to the American Cancer Society to fund cancer research, education, advocacy, and patient and family services. For every chip deposited into the box, Perficient will donate $5 to the American Cancer Society. Help us pay it forward to build a better world.

After stopping by our booth, we encourage you to join our sessions and spend part of your day hearing from our experts.

Wednesday, October 16 | 1:30 PM – 2:00 PM

Is AI Bias the New Elephant in the Room?

Description: Join Perficient’s Megan Jensen, portfolio specialist, and other leading women of Sitecore as they explore strategies for fostering equitable AI. From tackling biases ingrained in data and algorithms to shaping ethical frameworks, our panel delves into actionable approaches for creating AI that reflects and serves diverse global communities. Discover insights on team diversity, ethical integration, and the importance of addressing biases to empower marginalized groups. Let’s ensure AI benefits society ethically and inclusively!

Wednesday, October 16 | 3:00 PM – 3:30 PM

SEO, GEO, SGE, and Beyond the Horizon: Using AI to Boost Page Rank, Site Performance, and Conversions

Description: In a rapidly evolving digital landscape, one goal remains consistent for every website: to reach and maintain the highest position possible in search engine results. But how can you ensure your site is set up to beat the algorithm game when the rules are constantly changing? Perficient’s Tiffany Laster, senior digital strategist, and Megan Jensen, portfolio specialist, will cover how AI is changing everything we thought we knew about SEO, what you need to change about your SEO right now, and how to prepare for what’s on the horizon.

Thursday, October 17 | 2:15 PM – 2:45 PM

Revolutionizing the Digital Healthcare Experience: A Panel on DXP Modernization

Description: Join Perficient’s Stephen Tynes, national Sitecore sales advisor and Mark Ursino, director, Sitecore, and marketing leaders from Emory Healthcare and Encompass Health as they share their experiences with modernizing their MarTech stacks from on-premises to PaaS and SaaS solutions. From building a roadmap with pragmatic project sequencing to connecting patient-focused platforms while ensuring HIPAA compliance, they’ll share how Sitecore and Perficient helped modernize their approach to digital experience and go beyond the concept of a “digital front door” to meet their patients’ increasing demands.

Getting Registered

If you haven’t yet made the decision to attend Sitecore Symposium, here are some compelling reasons to help you justify your trip. Symposium is the largest gathering of the global Sitecore community. This is the perfect opportunity to network and build relationships with like-minded individuals.

To register, visit the official conference registration page. General conference passes start at $1,849 and will be raised to $2,049 starting October 1.

Your pass includes:

• Mainstage keynotes and product roadmap
• Celebrity and guest keynotes
• Breakout sessions
• Customer showcases
• Access to the Solutions Pavilion
• Product demos with experts
• Theater sessions
• Welcome reception and happy hour
• Symposium’s exclusive party
• Lunch and refreshments
• And more!

Our Expertise

As a Sitecore partner, we have designed, implemented, and delivered many enterprise-level sites powered by Sitecore Experience Platform. We know how to get the most out of this versatile digital experience platform and create highly effective and personalized experiences for your customers. Perficient has the right solution for you and we can’t wait to talk more at Symposium.

Sitecore Content Hub is a world-class platform for centralizing and managing content across various channels. It helps businesses organize and streamline often chaotic, messy content operations. It does this by providing an architecture or schema for content and its interconnections. A schema defines how different types of assets are structured, organized, related to each other.

What is the basis of that architecture? I struggled with understanding completely when I first began with DAMs. So, hopefully, the following concepts I’ve put into more understandable terms will help make Content Hub’s data model clear for you:

• Entities: A distinguishable object or concept. A person, a product, a company, a brand. These are the core items in the system.
• Relations: Connections between entities. How entities are related to each other.
  • Parent-Child relation: two entities where one entity, The Parent, holds a hierarchical position higher than that of its related entity or entities, The Child or Children. The Child is dependent on the Parent.
• Cardinality: Cardinality is the number instances of an entity that are connected to another entity. It’s the nature and scope of the relation.
  • Cardinality types
    • One-to-one: One item connected with only one other item.
      • Simple example: Mike has a BMX bike, and he owns no other bikes.
      • Real world example: A bicycle has one specific product image used across all marketing materials.

• • • One-to-many: One item connected with multiple items.
      • Simple example: Mike has a BMX bike, a mountain bike, and a ten-speed bike.
      • Real world example: A bicycle brand, Cool Cycles, has images, videos, and spec sheets used across all marketing materials.
    • Many-to-many: Multiple items connected to multiple other items.
      • Simple example: Mike, Spike, and Ed have bikes. Mike sometimes rides Spike’s bike, Spike sometimes rides Ed’s bike, and Ed sometimes rides Mike’s bike.
      • Real world example: Cool Cycles has a summer marketing campaign sharing a video from another summer marketing campaign, and both campaigns are sharing images with multiple Q3 campaigns.

All of these interconnected elements create a robust framework for organizing and managing content in a scalable, efficient way, bringing order to content chaos.