Beyond sharing our success story, the symposium unveiled groundbreaking innovations with significant implications for California’s public sector. Here are three key takeaways that every digital leader in government would benefit from understanding.

1. The Launch of SitecoreAI: Agentic Intelligence for the Public Sector

Sitecore unveiled SitecoreAI, a next-generation digital experience platform that positions artificial intelligence at the center of digital marketing and content delivery. Built on the foundation of Sitecore XM Cloud, this composable SaaS platform introduces the Agentic Studio, a collaborative workspace where marketers and AI work together through 20 AI-powered agents that automate workflows from campaign planning to content migration, production, and testing.

Why the California Public Sector Should Care

While the private sector focuses on “marketing,” government agencies confront parallel challenges in constituent communication, public information management, and service delivery. California is already leading the nation in the responsible deployment of AI for government services, as evidenced by Governor Newsom’s GenAI initiatives. SitecoreAI’s agentic intelligence addresses the actual operational needs of government agencies:

Content Operations & Public Information:

• Legislative and policy updates: When regulations change, AI agents can help identify all affected pages across your site, draft updates based on official documents, and flag content requiring human review, transforming a weeks-long manual process into days.
• Emergency content deployment: During wildfires, public health emergencies, or natural disasters, AI agents can rapidly deploy pre-approved content templates, update incident information across multiple pages, and ensure consistent messaging.
• Multilingual content at scale: California serves constituents in dozens of languages. AI agents can accelerate translation workflows while ensuring culturally appropriate terminology, though human review remains essential for accuracy and nuance.
• Content migration: Moving from legacy systems to modern platforms  typically requires months of manual work. AI agents can automate much of this heavy lifting.
• Routine updates: AI can handle repetitive tasks like updating contact information, office hours, or program deadlines across multiple pages.
• Improved search results: AI-powered search that understands intent (e.g., “apply for assistance” vs “eligibility requirements”)

2. Moving Beyond the Website: Content Discovery in the Age of AI Summaries

CEO Eric Stine emphasized a fundamental shift: “We’re living in the world beyond the website. Discovery is no longer driven by search; it’s powered by attention. Brands earn that attention in social media feeds and AI-generated summaries when they show up in the right moment with the right message.”

Californians are increasingly finding government information through AI-powered search summaries, voice assistants, and social media rather than directly navigating to agency websites. This shift has massive implications for how public sector organizations deliver critical information.

At SymSoft, we’re already helping California agencies prepare for this multi-channel reality by building a platform-agnostic, API-first content infrastructure that’s optimized for AI discoverability, while maintaining the accuracy and accountability that government requires.

3. The “Fans First” Philosophy: Eliminating Friction in Government Services

Keynote speaker Jesse Cole of the Savannah Bananas brought his “Fans First” philosophy to the symposium, emphasizing that every moment of friction, from sign-up to service, is an opportunity for your audience to walk away. Sitecore’s product vision centers on eliminating these friction points to build trust and loyalty.

Government services have historically been synonymous with frustration: confusing forms, broken links during emergencies, information buried in PDFs, and websites that don’t work on mobile devices. But it doesn’t have to be this way.

The “Fans First” philosophy translates directly to “Constituents First” for government:

• Every additional click to find wildfire evacuation information is a potential life-safety issue.
• Every confusing form reduces participation in critical benefit programs.
• Every broken link during an emergency erodes trust in government.
• Every accessibility barrier excludes vulnerable Californians who need services most.

Our recent work with Cal FIRE and other state agencies exemplifies this principle. We unify fragmented information across multiple sites, enhance search functionality, incorporate engaging visuals, and optimize an interactive map relied upon by millions of users during critical events to eliminate friction in delivering government services.

The SymSoft’s take

The innovations unveiled at Sitecore Symposium 2025 extend far beyond marketing automation and content management. They represent a fundamental shift in how governments can engage and serve their constituents in a GenAI-first world.

At SymSoft, we’ve spent nearly two decades helping California’s public sector stay ahead of emerging technologies and evolving citizen needs. Today, we’re partnering with agencies such as CDTFA, CAL FIRE, and DWR to deliver essential information through AI-powered summaries and voice assistants, extending service delivery far beyond the traditional website homepage.

Whether your agency is navigating a legacy CMS, planning a major digital modernization, or seeking to understand how Sitecore’s latest innovations can advance your mission, our team is ready to help.

Kevin shares his perspective—and we further elaborate—on:

1. Forming partnerships up, down, and across the organization.
2. How to select the right vendor partner for the intranet project?
3. How to deliver a project in 90 days by accelerating the project timeline?
4. How can rapid prototyping be incorporated into a time-constrained project?

Watch the video starting at about 3 minutes in, or skip to specific parts using the links above.

DWR’s intranet project was successful in large part because of the stakeholders’ attention and the team’s dedication. To deliver the project in such a short timeframe (90 days), we needed to form strong partnerships:

Kevin See: Now, here comes the fun part. How did we do it? We had to form partnerships — the partnership with the business, the partnership with technology, and of course, our vendor partnership. The first really big piece is — our director was in full support of this initiative, but we also had executive sponsorship from our deputy director of business operations, which runs the horizontal business. So everything from HR to IT is run under business operations.

The next part is the partnership between the director’s office, where Bianca is at, and the technology office [Kevin’s office]. Bianca represents the policy, the content, and the features people want. I represent the technology in terms of how we did it.

The last very important piece is that partner engagement. We had to find a partner that met the speed we wanted to go with, that also shared the same values, vision, and goals that we wanted to share. And have the flexibility to dynamically shift where we needed to to get the job done. And that was really [the case] with our SymSoft partner and working with Bhavik.

[The transcript was edited for clarity and brevity from the original audio recording. References to the slides were removed from the transcript.]

Forming partnerships up, down, and across the organization is crucial for the success of an intranet project.

In a typical project, vertical communication between supervisors and their reports is a natural extension of a regular reporting routine. Many times though, that same routine and reporting frameworks can steal attention from the project at hand, because other things may take priority or urgency, and meetings may be repurposed for other pressing topics. Also, while it makes perfect sense to include stakeholders from across different divisions and offices, oftentimes their attention is elsewhere, and their calendars are difficult to coordinate.  

In short, partnerships require dedication, structure, and excitement, which is in many cases much easier to accomplish if the team is nimble and focused and the communication is direct and candid, instead of managed and indirect.

Not everyone has the opportunity to form small teams as we had at the DWR’s project. This is why in large organizations, we often suggest inviting divisional representatives with decision-making power delegated by the division’s head. And especially if the division executives are stretched too thin by directly participating in the project. A useful model for defining stakeholder roles and responsibilities is the RACI matrix, which describes who is Responsible, Accountable, Consulted, and Informed.

To secure resources and bandwidth across divisions get executive support with a clear vision for the project’s success. Equip your leadership with talking points and clear engagement requirements, so that they can relay the message with better clarity about the timelines, efforts, expectations, and specific action items. It’s much easier for divisions to commit resources when expectations are clear.

How to select the right vendor partner for the intranet project?

To identify whether the vendor partnership will be successful, it’s useful to ask a few questions:

1. What type(s) of vendor contributors are you going to collaborate with during the course of the project? Will you work with the experts directly, or will someone be a liaison between you and the expert? Are you looking for a vendor that can participate in strategic decisions, or are you looking at the production partner only? 
2. What is the team’s availability for the length of the project? Who is engaged at different stages of the project? What will the handover from discovery, to design, to development, to deployment look like? Is there any quality control to ensure a smooth transition between different stages of the project?
3. What are some other functions inside the client organization that might contribute to the project? What will be their availability? Will we get reviews and approvals in a timely manner? How will the project team present work in progress to internal stakeholders and seek feedback?

Asking these questions from the perspective of the project goal will help you realistically allocate internal resources, budget for external help, and set timeline expectations. 

Now that we identified partnership considerations, let’s explore some practical tips and tricks that can help us accelerate project delivery. 

How to deliver a project in 90 days by accelerating the project timeline?

Let’s start with Kevin’s insights from the intranet project:

Kevin See: The “how” part is the agile delivery model. We had 90 days to get it done. Why 90 days? We had to get it done by Christmas time. That was our goal. Our time and our resources were tightly controlled. Our scope was to build an awesome and engaging intranet that employees love. It is very broad in scope in terms of what it’s going to be delivered.

Our time, as I mentioned, 90 days, got to get it done by Christmas time. Our resources? Well, that was our team. We had the resources that we had, and that was it. So we had to do all that within this very short and tight scope and build the intranet that people would use.

Decision- and policy-makers were a part of the product team. It wasn’t where we had a decision- and policy-makers that met once a month to talk about where the challenges are. The typical process in terms of how it goes is a steering committee. [But] they were actually a part of the team on a day-to-day basis. Bianca and I met literally every day or every other day. Between Bianca, Bhavik, and myself, we saw each other more than we saw our families within this 90-day timeframe. We shared a single vision, the vision of building the intranet that employees love, the vision of building the intranet within 90 days. And to get it done.

How did we apply agile delivery to the DWR’s intranet project?

To help us accelerate the project timeline, we used the agile delivery model and rapid prototyping (more about rapid prototyping below). We were able to utilize agile delivery because we met a couple of important essential ingredients:

1. We worked as a small, fast team. While it is possible to apply agile delivery to a much bigger team of teams, it would require some preparation time to organize decentralized communication between smaller teams that follow the agile approach. We didn’t have the luxury to step back, so individual team members instead prioritized this project and focused on fully understanding the ins and outs in order to make informed decisions. By keeping the team small, we completely removed any overhead.

2. We communicated daily. Granted, daily communication wouldn’t be possible with a much larger team spread across multiple projects. The cost of task and project switching would be too high, and it would require additional effort to maintain the common vision and priorities.

3. We provided feedback instantly. When the team is focused on the project with little to no distractions, feedback and decisions are made on-the-fly and based on shared understanding and common knowledge of the project.

4. We made quick adjustments and shortened release cycles. Because the team was very intimate with the technical platform (Sitecore), it was possible for us to update and compile features and to try different options. This wouldn’t be possible without both content and platform owners’ expertise in content publishing on the Web. 

5. We trusted one another. To develop trust, it is important to have a vision of the outcome that is attainable as well as assemble a team that shares that vision. A clear vision also helps with prioritizing features.

6. We prioritized features based on the project goals. As we were developing and implementing features, we developed a good sense of how much each addition or change would impact timelines and efforts. Instead of only focusing on development time, we also considered organizational policies and content governance. A good method for feature prioritization is the MoSCoW analysis that identifies Must-have, Should-have, Could-have, and Will-not-have features.

If your organization hasn’t already adopted an agile methodology, we suggest trying it with a small team that can operate within the framework described above. It is also useful to start implementing agile in your organization by following the agile manifesto:

Individuals and interactions over processes and tools.

Working software over comprehensive documentation.

Customer collaboration over contract negotiation.

Responding to change over following a plan.

How to prepare for a tight deadline project?

Even if you don’t follow agile methodology, or are not sure if you’d end up applying it, any project can move quickly and meet deadlines with some basic preparation:

1. Commit to the minimum projects requirements.
2. Define project goals and success criteria.
3. Secure executive sponsorship.
4. Book important meetings far in advance.

How to keep the project moving?

There are also a number of simple practices teams can implement and stick to in order to keep making good progress and avoid pitfalls:

1. Appoint a project manager who will attend all meetings, track decisions, and serve as an information hub. Best results are accomplished when they work closely with the vendor’s project manager.

2. Show something tangible early. It’s much more cost-effective to course-correct a proof of concept or a prototype than a fully developed project. Depending on the fidelity level, and stakeholder experience, it’s a good idea to present progress in a broader context of project requirements.

3. Keep key decision-makers in the loop by presenting small changes often. This will make it easy for them to recall the previous decisions and ask questions early, rather than approving a major milestone without enough context.

4. Contain the scope by always going back to the minimum project requirements. Any additional ideas and opportunities should be moved to the backlog and revised after the must-have features are designed, implemented, and tested.

How can rapid prototyping be incorporated into a time-constrained project?

DWR’s team is a huge fan of rapid prototyping, especially since they were deeply invested in the project and excited about the possibilities. 

The line between rapid prototyping and agile methodology is sometimes blurry. Rapid prototyping focuses on the software design from the user and business stakeholder perspective, while agile methodology applies to software development. The confusion stems from the fact that both are iterative methodologies with short release cycles, and both can be performed in the software environment. Still, it’s important to remember that prototypes are not production-ready. 

For example, before committing to a full-blown web form that connects to various systems and databases, you might embed a Google Form into a page to validate the user flow. Or, before committing to a custom developed data-dashboard, you might embed a Tableau prototype as an iframe. Yet another example is prototyping a widget without actually connecting it to the database. None of these examples would be shipped to production, but would give everyone a good idea of whether the feature makes sense to develop further or not.

Compared to the waterfall approach, which includes detailed planning and rigid requirements outside of the development environment, rapid prototyping enables quick validation of scaled features and provides a short feedback loop. In short, rapid prototyping boosts decision-making processes, dramatically reducing refactoring in the actual development phase.

Kevin See: We’ve done a lot of things in terms of rapid prototyping, meaning: what we saw in the morning could be dramatically different by the evening time. It can be 180 degrees. “You know what? That feature worked. [Or] it didn’t work.” What was the benefit behind that? We might have lost a couple of hours. In a typical development timeframe, a feature might take weeks or months to get done, and you lost all that time. But we worked with a partner, with a business that really was aligned with what we were trying to do, and that is to get the job done, and course-correct and shift, as fast as we want to shift and course-correct.

I think this was pivotal in terms of getting the platform that can do that, finding a partner that’s willing to do that with you, and a business that is truly engaged and is a part of that process. “Yep, that didn’t work. Let’s move on. Yep, that worked. Let’s move on.” And I think this is key in how we got this thing done within this very tight and short timeframe of building the Department of Water Resources’ intranet.

As previously mentioned, rapid prototyping goes hand in hand with the agile methodology, because it streamlines quick adjustments and shortened release cycles. However, it is the most suitable for experienced teams who can make such quick changes, validate options with stakeholders, and make informed decisions. This can also be a disadvantage, since rapid prototyping requires the most knowledgeable and experienced personnel.

Lastly, rapid prototyping is also effective in MVP (minimum viable product) development, where the PoC (proof of concept) is more important than a specific implementation approach. When the timeline is short, rapid prototyping results in a tangible output very early. Once approved, the MVP can be moved into the development phase.

Conclusion

While large-scale capital projects can be delivered in a very short timeframe, they require an experienced team, executive support, and dedicated stakeholders. By applying methodologies and frameworks, such as RACI stakeholder roles, MoSCoW prioritization, agile project management, and rapid prototyping, even the most challenging projects can be delivered on time and budget.

Have a massive project that needs to be delivered fast? Contact us and let’s start the conversation.

In over 15 years of redesigning websites and implementing Web content management systems for our enterprise and government clients, we have identified five essential activities that are often missed in the project planning. In such cases, the whole project might be at risk because time and internal resources are not allocated. Of course, when this happens, there are still ways to deliver a project, but it might require readjustment that could have been easily avoided altogether.

Before you plan for your next Web design or Web CMS implementation project, we suggest you consider the following five activities of a successful redesign:

1. Content Production, Editing, and Migration
2. Web Content Accessibility Support
3. Application and System Integration
4. Organizational Change Management (OCM)
5. Maintenance and Support

1. Content Production, Editing, and Migration

Whether you are redesigning a site or launching a completely new website, content migration and new content production are critical activities that require careful planning and consideration. 

Content updates and organization typically require engagement of the content owners and subject matter experts, such as program managers or communication teams. Failure to plan for their involvement results in low engagement and unanticipated workloads that nobody allocated for. It is common for organizations at that point to step back and re-identify project stakeholders, which in many cases results in inconvenience and delays.

To avoid surprises down the road, ask the following questions:

1. How much content is currently there on the existing website?
2. Will all the current content be migrated to the new website?
3. Can content be archived?
4. Does some content belong to the Intranet or Extranet rather than the public-facing website?
5. What is the legally required content that needs to be migrated over to the new website?
6. Do you need to create any new content, or update any existing content for the new website?
7. Will you introduce new content formats, such as photography, illustrations, or video?
8. Who will produce or edit content?
9. Who will migrate the content?
10. Who will review and approve content editing and migration? 

Answering these questions prior to starting the project will help you define a more realistic scope, and identify additional resources needed to ensure the delivery of a comprehensive website solution.

2. Web Content Accessibility Support

Accessible websites combine accessibility compliant platforms (e.g. content management systems or document filing systems) and accessibility compliant content.

While most public sector website redesign or implementation projects require an accessibility compliant platform, software, and design system, content accessibility compliance workflows and procedures are often overlooked. This can create challenges after the project is completed and the website content continues to evolve, so it is essential to establish and adopt processes to monitor and ensure accessibility compliance moving forward.

When planning your next accessibility compliant project, ask the following questions:

1. How will you test and validate website accessibility after the project is completed? How will you keep the website accessible? This is especially important in public sector websites that need to self-certify for accessibility compliance (AB 434 in California).
2. Are there any files and documents that need to be remediated for accessibility compliance before publishing on the website? (In many cases the answer is yes.) How many of such documents are already remediated? Do you have a strategy set in place to conduct remediation of the non-compliant files and documents? In our experience, the volume of documents that require at least some accessibility remediation comes as a surprise to many organizations.
3. Do you have the technical resources and expertise to maintain an accessibility compliant website? If not, how do you plan to address the gap?

3. Application and System Integration

Many organizations, especially in the public sector, provide website visitors access to business applications through their websites. These applications help with self-service tasks and therefore significantly optimize business processes, digital transactions, and time required to serve thousands and millions of users. Such applications are often the main reason users visit the website, so consider business application integration while planning for a website redesign or implementation project.

To help identify tasks and resources that should be part of your project, review all applications currently available to the users through the website. Consider engaging the business application owners and technical support groups in the planning.  

In our experience, there are a few common scenarios:

1. Business applications are kept as-is. They retain their look-and-feel and are hosted in the existing environment. Applications are not integrated with the main website but are merely hyperlinked. In this case, the user experience and accessibility could end up being suboptimal, but the project timelines are more predictable.
2. Existing application rebranding and visual design alignment. This is a common option for organizations that are able to dedicate technical staff who can apply the main project’s design system to the business application.
3. API development and integration. This is the most future-proof solution, depending on the CMS and how much development effort is required by the complexity of the business application. Benefits of API integrations include a unified brand and user experience because the user stays within the same website, which opens up possibilities for additional features such as content personalization or user profile functionalities.

Sometimes, the rebranded applications are embedded through iframes. However, we strongly suggest avoiding this approach as it may create accessibility challenges that are expensive to address. Typically, video embeds are somewhat easier to maintain, but custom data dashboards might create more problems than benefits when embedded through an iframe.

As always, there are multiple solutions to a problem, but we recommend at least high-level planning, well in advance, to avoid surprises later in the process.

4. Organizational Change Management (OCM)

Implementing new systems and tools may require changes to the organization’s internal processes, procedures, and day-to-day operations. Planning and managing the change is sometimes omitted from the project planning process, resulting in low stakeholder engagement and slow adoption.  

When planning the project, changes and challenges that need to be identified include:

1. Changes in roles and responsibilities.  
2. Implementation of new processes, policies, and procedures.
3. New resources, skills, or abilities required within the organization.
4. Legal requirements for implementing the changes.
5. Impact of the changes on the organization’s workload.  

We have partnered with many of our clients to help lead organizational change management throughout our projects, which has been vital for successful implementations and enduring solutions.

5. Maintenance and Support

Although most website redesign or implementation projects include a knowledge transfer deliverable, some miss the option of engaging the implementing partner to provide ongoing maintenance and support after the project is complete.

Having maintenance and support in place allows organizations to gain additional knowledge of the solutions by monitoring issue resolution procedures, collaborating with the vendor to resolve real-life situations, and learning by doing. Having maintenance and support in place frees up internal resources to focus on more strategic tasks than day-to-day monitoring.

When planning the project, thinking about the organizational capabilities will provide you with a general idea of the maintenance and support requirements that should be included in the project’s scope. Consider:

1. Your organization’s familiarity with the platforms and technologies used in the project.
2. What resources will be available to support the solution after the new website is launched.  

Conclusion

We hope this list of considerations will give you a better idea on how to scope website redesign or Web CMS implementation projects in your organization.

For further questions, and help in scoping projects, please contact us.

Alphabetical listing of items such as navigation items or search filters is one of the easiest ways for people to navigate and find what they are looking for in a long list of terms.

However, the search filters returned from Solr are not sorted alphabetically.

Instead of the natural language terms, Solr returns a list of facet IDs in the order that Solr internally determined based on relevancy.

Below is an example of the Solr Search data structure, which makes sense to the algorithm, but not necessarily to the website visitors that use search filters.

[0]: "9955d3531ccb4e6e8a92c7e484d329ca"
[1]: "dac1e325382d48569cabea48c83165cd"
[2]: "e56edf635d4048a098bcbeaef8541975"
[3]: "ef1770d934f54b6b821d29be800667b9"

Looking at the example above, items are represented as Sitecore GUIDs. Applying an ascending order operation to the list above won’t make sense, because at this point we don’t know what’s the actual user-friendly label associated with each ID.

To apply meaningful sorting to Solr search results, we have to do a little bit of preparation.

1. Make a new list.
2. Translate each ID into the corresponding Sitecore Item and add it to the newly created list.
3. Find out each item’s associated title.
4. Sort the new list based on the associated title.

Translated to the code language, it looks like the example below:

ret = asc ? ret.OrderBy(x => x["Title"]).ToList() : ret.OrderByDescending(x => x["Title"]).ToList();
List ret = new List();
foreach (var filter in allFilters) {
    Item filterItem = Sitecore.Context.Database.GetItem(new Sitecore.Data.ID(filter));
    ret.Add(filterItem);
}

I hope this helps you sort the returned facets. For a live example, please visit CCC’s Custom Document Search.

As always, feel free to reach out to us with feedback and further questions.

Some organizations have not adopted intranet platforms, instead opting to rely on a variety of other solutions, such as email and third-party messenger systems. Others have implemented intranets which, after years or decades of growth and changes in organizational scope and scale, no longer meet their present-day goals and vision.

Whether you have an existing intranet or not, there are common problems that can indicate that a modern intranet system is necessary for your continued success.

Organizations sometimes reach a halt where the necessary scope of a new intranet system is daunting, but the ability to grow and improve their level of service requires attacking the problem.

In early 2019, we were approached by the California Department of Water Resources. The scope of the DWR is immense. They are responsible for supplying water to 27 million Californians and 750,000 acres of agricultural land, and also provide oversight for more than a dozen dams in the state of California. These responsibilities require a large, diverse workforce: the DWR is composed of approximately 3,500 employees across 14 offices in various urban and rural locations.

As you can imagine, any and every hindrance to communication was keenly felt. They knew their needs had outstripped their existing internal communication infrastructure. But it takes a significant, committed effort to shift focus from short-term, day-to-day priorities, and taking a step back and seeing the big picture.

To their credit, DWR recognized they had hit a point where they couldn’t hide from the challenge any longer, and had to get all relevant stakeholders involved: execs, operations, IT, communications, HR and legal, and of course, their base level employees.

An inadequate intranet often results in the loss or misplacement of institutional information, failures in communication between executives and employees, and ongoing difficulties for the rank-and-file.

The difficulties that arise from aging, insufficient intranet are often felt both at the organizational level, and at the personal level.

Problems that arise at the macro scale can include:

• Loss of documentation. Documents—both archival and current—can become difficult to find, as employees come and go and filing systems shift and change over time. It can become necessary to conduct weeks- or months-long content audits to identify what documents exist, and where.
• Disjointed communication. As with document archives, an inadequate intranet system results in the fragmentation of every aspect of communication. Knowledge is lost, performance metrics are opaque, and efficiency is compromised. The result is an incoherent execution of an organization’s vision, mission, and values.
• Social isolation. As a result of poor communication, workers often feel isolated, cut off from others by the four walls around them. They have no way of seeing the larger picture, and no way to appreciate the positive impact of their work. Work often comes to feel repetitive and unfulfilling at all levels.
• Lack of community and mission. Public social media platforms are appealing for a reason—they give a sense of community and connection. Failure to provide for the social needs of the workforce results in an organization that has no central identity, with mission statements that carry little or no real-world weight. Organizational plans, milestones, and updates are not shared, never making it out the door of the boardroom.

Shortcomings in intranet sophistication are also evident to the rank-and-file. Common employee-level issues include:

• Intranet as info dump. A lackluster intranet often becomes nothing more than a bucket for informational storage. In these instances, file search and navigation features are inadequate. This means that documents, manuals, and guidelines are difficult or impossible to find, and multiple, conflicting versions are generated over time.
• Distribution outside the intranet. In these situations, the sharing of information often occurs outside of the intranet, with employees instead relying on email, and third-party messengers like Teams and Slack. Consequently, not everyone has the same information, or even the ability to access the same information.
• Improper data storage. Because of distribution occurring outside the intranet, files are often archived as email attachments or in user drives, rather than in common storage.
• Success not communicated. With an intranet not being an effective means of communication, personnel successes are never communicated.

But the most obvious symptom of an inadequate intranet is that it delivers an experience that is subpar to Internet services and third-party communication tools, so that it becomes the option of last resort.

But these are problems that can be resolved by making a comprehensive, top-to-bottom commitment to developing an intranet that betters your entire organization.

To return to the challenge facing our client, DWR, they recognized that their existing intranet did not serve the needs of their employees. A platform was needed that was flexible enough to accommodate the unique needs of each employee, as well as a unified connection and understanding of key needs and goals.

In the summer of 2019, we brought together over a hundred and twenty employees to participate in focus groups for the intranet redesign. These participants were specifically selected to better understand the diverse needs within the workforce, based on their skills, geography, and position within the network. Employees were asked to provide feedback on knowledge search information operation and networking. Our team listened and learned from DWR’s employees. And then, we prioritized those needs moving forward.

It was a significant challenge. But we succeeded because we led off by asking a handful of critical questions:

• If you could wave a magic wand, what are the three things you would fix immediately?
• What are you doing right now to address organizational challenges? What has worked, and what hasn’t?
• What are the long-term goals of the organization?
• How would the success of the project be measured?

In the future, we will address how we develop a successful intranet system that meets the needs of an organization’s mission, as well as its rank-and-file staff. But every successful intranet project addresses three key needs:

• Accountability. At the outset, personnel are identified as being responsible for the successful execution of the project, so that the organization’s mission, values, and vision are sustained.
• Curation. Any successful intranet requires ongoing information curation, to ensure consistency in organization. There must be dedicated resources in place which will edit content, optimize, review, archive outdated content, track intranet performance, talk to employees, and conduct regular (often light weight) UX studies.
• Adoption. An intranet is not a project that, once it is completed, it is placed on a shelf. It is an operational asset. Plans must be put in place for how the organization will transition from the old intranet system, to the newly developed one. All stakeholders must commit to making this transition. Otherwise, the organization will be in limbo between the legacy system, and the new one.

In future posts, we will address other key topics in the development and launch of successful intranet systems. In the meantime, enjoy the video presentation we delivered at Sitecore Symposium and contact us with specific inquiries about your intranet project.

We weren’t sure what was happening but in the logs, we saw that it was being triggered during Item Locking and Indexing.
After some research, it was apparent that this was being caused by invalid XML in the lock field. Which looks like this

This issue can appear in the Sitecore logs in the following ways:

Error 1:
416 16:06:36 ERROR First 200 characters: >

Error 2:
416 16:06:36 ERROR Call stack: at Sitecore.MainUtil.GetCallStack() at Sitecore.Xml.XmlUtil.LoadXml(String xml) at Sitecore.Data.Locking.ItemLocking.GetLockField() at Sitecore.Data.Locking.ItemLocking.GetOwner() at Sitecore.ContentSearch.ComputedFields.ParsedLockOwner.ComputeFieldValue(IIndexable indexable) at Sitecore.ContentSearch.AbstractDocumentBuilder`1.<>c__DisplayClass57_0.<AddComputedIndexFieldsInParallel>b__0(IComputedIndexField computedIndexField, ParallelLoopState parallelLoopState) at System.Threading.Tasks.Parallel.<>c__DisplayClass42_0`2.<PartitionerForEachWorker>b__1() at System.Threading.Tasks.Task.InnerInvokeWithArg(Task childTask) at System.Threading.Tasks.Task.<>c__DisplayClass176_0.<ExecuteSelfReplicating>b__0(Object ) at System.Threading.Tasks.Task.Execute() at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx) at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx) at System.Threading.Tasks.Task.ExecuteWithThreadLocal(Task& currentTaskSlot) at System.Threading.Tasks.Task.ExecuteEntry(Boolean bPreventDoubleExecution) at System.Threading.ThreadPoolWorkQueue.Dispatch()

Error 3:
10144 16:06:36 ERROR Attempted to load invalid xml. Exception: System.Xml.XmlException Message: Data at the root level is invalid. Line 1, position 1. Source: System.Xml at System.Xml.XmlTextReaderImpl.Throw(Exception e) at System.Xml.XmlTextReaderImpl.ParseRootLevelWhitespace() at System.Xml.XmlTextReaderImpl.ParseDocumentContent() at System.Xml.XmlLoader.Load(XmlDocument doc, XmlReader reader, Boolean preserveWhitespace) at System.Xml.XmlDocument.Load(XmlReader reader) at System.Xml.XmlDocument.LoadXml(String xml) at Sitecore.Xml.XmlUtil.LoadXml(String xml)

Solution:
We knew that we needed to find out how many and which Sitecore Items had this issue so that we could go and fix them through the Content Editor.  We decided that SQL was out best shot!

Run the following query in your Master database. The query returns the list of Items that have Invalid XML in the __Lock Field

SELECT TOP (1000) [Id]
,[ItemId]
,(select Name from Items where FieldId = ID) as FieldName
,[Value]
,[Created]
,[Updated]
FROM [Fields]
where [Value] = '>' or [Value] = '<'

In my case, it returned 1 record in the master database for the __lock field.

I then use the content editor and searched for the Item that was affected, and cleared out the lock field, as an admin of course! One its cleared out make sure you save and publish.

If you are still receiving the error after clearing the fields, execute the same query on the VersionedFields and the SharedFields Table:

SELECT TOP 100 ItemId,(select Name from Items where FieldId = ID) as FieldName, LEN([Value]) as 'Length'
FROM [VersionedFields]
where ([Value] like '<%' or [Value] like '<' or [Value] like '%<')
Order by [Length]

SELECT TOP 100 ItemId,(select Name from Items where FieldId = ID) as FieldName, LEN([Value]) as 'Length'
FROM [SharedFields]
where ([Value] like '<%' or [Value] like '<' or [Value] like '%<')
Order by [Length]

Hopefully, this helps!

Sitecore FXM uses what they call a Beacon script to track and record the current users’ behavior (i.e interactions). Including this script will allow you to execute the following methods to track events, goals, outcomes, and campaigns. However, there are no available methods to identify a contact or update a contact’s facet data. This functionality is needed when we have a Non-Sitecore site using FXM that is also the application responsible for logging the user in, and then personalizing content based on a given attribute stored in xDb.

1. SCBeacon.trackEvent
2. SCBeacon.trackGoal
3. SCBeacon.trackOutcome
4. SCBeacon.trackCampaign

Looking at Sitecore 9.1 configs for FXM in Sitecore.FXM.config and Sitecore FXM assembly lead us to the TriggerEventsProcessor which is responsible for handling calls the Beacon method’s referrenced above.

<tracking.triggerpageevent>

  <processor type="Sitecore.FXM.Pipelines.Tracking.TriggerPageEvent.TriggerEventsProcessor, Sitecore.FXM" resolve="true" />

</tracking.triggerpageevent>

public class TriggerEventsProcessor : ITriggerPageEventProcessor
  {
    private readonly IAnalyticsDefinitionsRepository _analyticsDefinitionsRepository;
    public TriggerEventsProcessor(IAnalyticsDefinitionsRepository analyticsDefinitionsRepository)
    {
      Assert.ArgumentNotNull((object) analyticsDefinitionsRepository, nameof (analyticsDefinitionsRepository));
      this._analyticsDefinitionsRepository = analyticsDefinitionsRepository;
    }
    public void Process(TriggerPageEventArgs args)
    {
      IPageContext currentPageContext = args.CurrentPageContext;
      Assert.IsNotNull((object) currentPageContext, "The current page is not tracked in the current session. No events can be triggered.");
      ITrackDescriptor trackDescriptor = args.TrackDescriptor;
      if (trackDescriptor is EventTrackDescriptor)
      {
        EventTrackDescriptor eventTrackDescriptor = (EventTrackDescriptor) trackDescriptor;
        this.TriggerPageEvent((IDefinition) eventTrackDescriptor.Definition, currentPageContext, eventTrackDescriptor.Data, eventTrackDescriptor.DataKey, eventTrackDescriptor.Extras);
      }
      else if (trackDescriptor is GoalTrackDescriptor)
      {
        GoalTrackDescriptor goalTrackDescriptor = (GoalTrackDescriptor) trackDescriptor;
        this.TriggerPageEvent((IDefinition) goalTrackDescriptor.Definition, currentPageContext, goalTrackDescriptor.Data, goalTrackDescriptor.DataKey, goalTrackDescriptor.Extras);
      }
      else if (trackDescriptor is CampaignTrackDescriptor)
      {
        CampaignTrackDescriptor campaignTrackDescriptor = (CampaignTrackDescriptor) trackDescriptor;
        currentPageContext.TriggerCampaign(campaignTrackDescriptor.Definition);
      }
      else if (trackDescriptor is OutcomeTrackDescriptor)
      {
        OutcomeTrackDescriptor outcomeTrackDescriptor = (OutcomeTrackDescriptor) trackDescriptor;
        OutcomeData outcome = new OutcomeData(outcomeTrackDescriptor.Definition, outcomeTrackDescriptor.CurrencyCode, outcomeTrackDescriptor.Monetary);
        IDictionary<string, string> extras = outcomeTrackDescriptor.Extras;
        if (extras != null && extras.Count > 0)
          outcome.CustomValues["FXM_CustomValues"] = (object) outcomeTrackDescriptor.Extras;
        currentPageContext.RegisterOutcome(outcome);
      }
      else
      {
        if (!(trackDescriptor is ElementMatcherTrackDescriptor))
          return;
        this.TriggerElement(((ElementMatcherTrackDescriptor) trackDescriptor).Item, currentPageContext);
      }
    }
  }

Taking a look at the processor, SCBeacon.trackEvent does exactly what it says and tracks specific actions but does not handle any contact identifications or contact updates.

The next step is to create the custom process by extending (inheriting) the Sitecore default TriggerEventsProcessor with the following code:

public class TriggerFXMEventsProcessor : Sitecore.FXM.Pipelines.Tracking.TriggerPageEvent.TriggerEventsProcessor
    {
        //private readonly IAnalyticsDefinitionsRepository _analyticsDefinitionsRepository;
        public TriggerFXMEventsProcessor(IAnalyticsDefinitionsRepository analyticsDefinitionsRepository) : base(analyticsDefinitionsRepository)
        {
        }
        public new void Process(TriggerPageEventArgs args)
        {
            IPageContext currentPageContext = args.CurrentPageContext;
            Assert.IsNotNull((object)currentPageContext, "The current page is not tracked in the current session. No events can be triggered.");
            ITrackDescriptor trackDescriptor = args.TrackDescriptor;
            if (trackDescriptor is EventTrackDescriptor)
            {
                EventTrackDescriptor eventTrackDescriptor = (EventTrackDescriptor)trackDescriptor;
                if (eventTrackDescriptor.Definition.Id.Equals(new Guid(("{A6202545-323F-42ED-B904-81079C762524}")))
                {
                    if (Sitecore.Analytics.Tracker.Current != null && Sitecore.Analytics.Tracker.Current.Contact != null)
                    {
                        UpdateandIdenifyContact(eventTrackDescriptor);
                    }
                    else
                    {
                        Log.Info("cannot found the contact for the current interaction", this);
                    }
                }
                else
                {
                    this.TriggerPageEvent((IDefinition)eventTrackDescriptor.Definition, currentPageContext, eventTrackDescriptor.Data, eventTrackDescriptor.DataKey, eventTrackDescriptor.Extras);
                }
            }
            else if (trackDescriptor is GoalTrackDescriptor)
            {
                GoalTrackDescriptor goalTrackDescriptor = (GoalTrackDescriptor)trackDescriptor;
                this.TriggerPageEvent((IDefinition)goalTrackDescriptor.Definition, currentPageContext, goalTrackDescriptor.Data, goalTrackDescriptor.DataKey, goalTrackDescriptor.Extras);
            }
            else if (trackDescriptor is CampaignTrackDescriptor)
            {
                CampaignTrackDescriptor campaignTrackDescriptor = (CampaignTrackDescriptor)trackDescriptor;
                currentPageContext.TriggerCampaign(campaignTrackDescriptor.Definition);
            }
            else if (trackDescriptor is OutcomeTrackDescriptor)
            {
                OutcomeTrackDescriptor outcomeTrackDescriptor = (OutcomeTrackDescriptor)trackDescriptor;
                OutcomeData outcome = new OutcomeData(outcomeTrackDescriptor.Definition, outcomeTrackDescriptor.CurrencyCode, outcomeTrackDescriptor.Monetary);
                IDictionary<string, string> extras = outcomeTrackDescriptor.Extras;
                if (extras != null && extras.Count > 0)
                    outcome.CustomValues["FXM_CustomValues"] = (object)outcomeTrackDescriptor.Extras;
                currentPageContext.RegisterOutcome(outcome);
            }
            else
            {
                if (!(trackDescriptor is ElementMatcherTrackDescriptor))
                    return;
                this.TriggerElement(((ElementMatcherTrackDescriptor)trackDescriptor).Item, currentPageContext);
            }
        }

        private void UpdateandIdenifyContact(EventTrackDescriptor eventTrackDescriptor)
        {
            try
            {
                Assert.IsTrue(eventTrackDescriptor.Extras.Any(), "FXM JS API - Parameter not passed");
                if (eventTrackDescriptor.Extras != null && eventTrackDescriptor.Extras.Any())
                {
                    var values = eventTrackDescriptor.Extras;
                    Assert.IsTrue(values.ContainsKey("uniqueId"), "FXM JS API - Parameter - uniqueId not passed");
                    Assert.IsNotNullOrEmpty(values["uniqueId"], "FXM JS API - Parameter - uniqueId in Empty");
                    if (values.ContainsKey("uniqueId") && !string.IsNullOrEmpty(values["uniqueId"]))
                    {
                        using (XConnectClient client = SitecoreXConnectClientConfiguration.GetClient())
                        {
                            ContactExpandOptions Facets = new ContactExpandOptions(new string[] {
                            PersonalInformation.DefaultFacetKey,
                            EmailAddressList.DefaultFacetKey,
                            PayLoad.DefaultFacetKey
                            });
                            Sitecore.XConnect.Contact contact = client.Get(new IdentifiedContactReference("ContactPayload", values["uniqueId"].ToString().ToLowerInvariant()), Facets);
                            PersonalInformation PersonalFacet;
                            EmailAddressList EmailAddressListFacet = null;
                            PayLoad PayLoadFacet = null;
                            var manager = Sitecore.Configuration.Factory.CreateObject("tracking/contactManager", true) as Sitecore.Analytics.Tracking.ContactManager;
                            if (contact == null) //if the contact is not existing in the system
                            {
                                contact = new Sitecore.XConnect.Contact(new ContactIdentifier("ContactPayload", values["uniqueId"].ToString().ToLowerInvariant(), ContactIdentifierType.Known));
                                client.AddContact(contact);
                                PayLoadFacet = new PayLoad();
                                FillPayload(PayLoadFacet, eventTrackDescriptor);
                                if (!string.IsNullOrEmpty(PayLoadFacet.FirstName))
                                {
                                    PersonalFacet = new PersonalInformation()
                                    {
                                        FirstName = PayLoadFacet.FirstName,
                                        LastName = PayLoadFacet.LastName
                                    };
                                    client.SetFacet(contact, PersonalInformation.DefaultFacetKey, PersonalFacet);
                                }
                                if (!string.IsNullOrEmpty(PayLoadFacet.Email))
                                {
                                    EmailAddressListFacet = new EmailAddressList(new EmailAddress(PayLoadFacet.Email, true), "Preferred");
                                    client.SetFacet(contact, EmailAddressList.DefaultFacetKey, EmailAddressListFacet);
                                }
                            }
                            else
                            {
                                PayLoadFacet = contact.GetFacet(PayLoad.DefaultFacetKey);
                                if (PayLoadFacet == null)
                                    PayLoadFacet = new PayLoad();
                                FillPayload(PayLoadFacet, eventTrackDescriptor);
                                if (!string.IsNullOrEmpty(PayLoadFacet.FirstName))
                                {
                                    PersonalFacet = contact.GetFacet(PersonalInformation.DefaultFacetKey);
                                    if (PersonalFacet == null)
                                    {
                                        PersonalFacet = new PersonalInformation()
                                        {
                                            FirstName = PayLoadFacet.FirstName,
                                            LastName = PayLoadFacet.LastName
                                        };
                                    }
                                    else
                                    {
                                        PersonalFacet.FirstName = PayLoadFacet.FirstName;
                                        PersonalFacet.LastName = PayLoadFacet.LastName;
                                    }
                                    client.SetFacet(contact, PersonalInformation.DefaultFacetKey, PersonalFacet);
                                }
                                if (!string.IsNullOrEmpty(PayLoadFacet.Email))
                                {
                                    EmailAddressListFacet = contact.GetFacet(EmailAddressList.DefaultFacetKey);
                                    if (EmailAddressListFacet == null)
                                        EmailAddressListFacet = new EmailAddressList(new EmailAddress(PayLoadFacet.Email, true), "Preferred");
                                    else
                                        EmailAddressListFacet.PreferredEmail = new EmailAddress(PayLoadFacet.Email, true);

                                    client.SetFacet(contact, EmailAddressList.DefaultFacetKey, EmailAddressListFacet);
                                }
                            }
                            client.SetFacet(contact, PayLoad.DefaultFacetKey, PayLoadFacet);
                            client.Submit();
                            manager.RemoveFromSession(Tracker.Current.Session.Contact.ContactId);
                            Tracker.Current.Session.IdentifyAs("ContactPayload", values["uniqueId"].ToString().ToLowerInvariant());
                            Tracker.Current.Session.Contact = manager.LoadContact(Tracker.Current.Contact.ContactId);
                            Log.Info("FXM JS API added contact "+ Tracker.Current.Contact.ContactId.ToString() + " for " + values["uniqueId"].ToString().ToLowerInvariant(), "FXM JS API");
                        }
                    }
                    else
                    {
                       Log.Error("FXM JS API - Parameter - uniqueId not passed", "FXM JS API");
                    }
                }
                else
                {
                    Log.Error("FXM JS API - Parameters not passed", "FXM JS API");
                }
            }
            catch (XdbExecutionException ex)
            {
                Log.Error("XDB Exception while adding or updating contacts " + ex.Message, ex, this);
                throw ex;
            }
            catch (System.AggregateException ae)
            {
                foreach (var e in ae.Flatten().InnerExceptions)
                {
                    Log.Error("Aggregate Error while adding or updating contacts " + e.Message, e, this);
                }
                throw ae;
            }
            catch (Exception ex)
            {
                Log.Error("Exception while adding or updating contacts " + ex.Message, ex ,this);
                throw ex;
            }
        }
        private void FillPayload(PayLoad payloadinfo, EventTrackDescriptor eventTrackDescriptor)
        {
            var values = eventTrackDescriptor.Extras;
            payloadinfo.UniqueId = values.ContainsKey("uniqueId") ? values["uniqueId"].ToString().ToLowerInvariant() : string.Empty;
            payloadinfo.CustomerName = values.ContainsKey("customerName") ? values["customerName"].ToString() : string.Empty;
            payloadinfo.FirstName = values.ContainsKey("firstName") ? values["firstName"].ToString() : string.Empty;
            payloadinfo.LastName = values.ContainsKey("lastName") ? values["lastName"].ToString() : string.Empty;
            payloadinfo.Email = values.ContainsKey("email") ? values["email"].ToString() : string.Empty;         
            payloadinfo.Language = values.ContainsKey("language") ? values["language"].ToString().ToLowerInvariant() : "en";
        }
    }

As you could see that even though I have inherited the Sitecore default TriggerEventsProcessor, I have used Process() method as is, instead of overriding with a check for the event’s definition as CONTACTEVENT({A6202545-323F-42ED-B904-81079C762524}) to update and Identify Contact. This will make sure that the default page event is not triggered when there is a huge amount of call to update contact via trackevent of beacon script from an external site.
The next step is to register the custom processor in Sitecore configuration using Sitecore config patching standard practice.

<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/" xmlns:role="http://www.sitecore.net/xmlconfig/role/" >
 <sitecore>
  <pipelines>
   <group name="FXM" groupName="FXM" >
    <pipelines>
     <tracking.triggerpageevent>
      <processor type="Project.Standalone.FXM.Pipelines.Tracking.TriggerFXMEventsProcessor, Project.Standalone" patch:instead="processor[@type='Sitecore.FXM.Pipelines.Tracking.TriggerPageEvent.TriggerEventsProcessor, Sitecore.FXM']" resolve="true"/>
     </tracking.triggerpageevent>
    </pipelines>
   </group>
  </pipelines>
 </sitecore>
</configuration>

Once the custom processor is registered, we need to create the CONTACTEVENT ({A6202545-323F-42ED-B904-81079C762524}) page event items in Sitecore. Navigate to /Sitecore/system/Settings/Analytics/Page Events path in the content tree and create page event as described below.

Now we can call the trackevent method after the load of the beacon script. There are different ways (refer to Sitecore documentation) to pass the updated contact data to the page event, it also depends on your implementation. I decided to use an extra dictionary of EventTrackDescriptor to send the contact details. To test you can call the trackEvent method in the developer console of your browser, once FXM script is loaded on the External Site.

SCBeacon.trackEvent("contactevent", {
                     xuniqueId: "0001181764-288089",
                     xcustomerName: "NICOLE TREJOS",
                     xfirstName: "NICOLE",
                     xlastName: "TREJOS",
                     xemail: "NICOLE.TREJOS@test.com",
                     xlanguage: "en"
                   });

You can see the new contact added using Experience Profile.

“Error: Invalid URI: The Uri string is too long.

The remote server returned an error: (414) Request-URI Too Long”

Looking at the configurations for SItecore 8.2 we noticed that Solr’s default request was set to POST by using a Sitecore support package as POST requests were not officially supported for that version of Sitecore. They were using the support package because they faced the same issue of the request size being too large for a GET request. And, this support package no longer seemed to work with version 9.1.

After looking around online I found articles pointing to a setting “ContentSearch.Solr.SendPostRequests” in the configuration file “C:\inetpub\wwwroot\trc91.local\App_Config\Sitecore\ContentSearch\Sitecore.ContentSearch.Solr.DefaultIndexConfiguration.config” and setting the value to true, should enable POST requests on Solr. Unfortunately, this didn’t work as we noticed that the search query was still being sent as a GET request. So, it seemed to have been working only for version 9.0 and not 9.1 (I have not tested this on 9.0).

Therefore, our next step was to reach out to Sitecore Support and they confirmed that the setting mentioned above doesn’t work and they have no plans of fixing it in the near future.

Instead, they gave us a workaround, to change the “requestHeaderSIze” attribute value to a higher value in the following file on your Solr server “[solr]/server/etc” (we set the value to 29000). Setting this value will allow Solr to support larger sizes for GET requests. It should look like this:

<Set name=”requestHeaderSize”><Property name=”solr.jetty.request.header.size” default=”29000″ /></Set>

We tried this workaround and we could confirm that the search component started working again. I hope this blog will help other Sitecore developers who might face a similar issue.

This article will provide you with a few examples of the advanced search experiences that are integrated with the Sitecore-based solutions we deliver to our customers, such as SMUD, DWR and DGS.

Sitecore Content Search API is responsible for communicating with search engine software such as Solr, a popular enterprise-level platform built on Apache Lucene™. Out of the box, the Content Search API retrieves the basic list of results, which works perfectly if the end user knows exactly what they are looking for. It’s a little less convenient for people who are not quite sure what they need, or simply don’t even know how to phrase the query.

SymSoft improves the original Sitecore Content Search API by adding methods that can retrieve other information — such as alternative query suggestion, or query term highlights in the list of results. This creates the user experience similar to the one provided by Google Search.

Let’s see them in action.

Alternative Query Suggestion

Alternative query suggestion will attempt to search content with the original keyword. In case there are no results to display, it will suggest an alternative query results based on similar existing words or phrases. Below is an example of the alternative query suggestion on a live website for the California Department of Water Quality.

Stemmed Search

Stemmed search improves user experience by expanding query to include all results that are related to the base form of the word used in the query. In the example below, using keywords with the same root — university and universities — will retrieve the same list of pages and documents (the root of the word university is universit).

Query Term Highlighting

Query term highlighting is useful in cases when the search query refers to multiple different contexts. Highlighted query terms help users understand the context around the keyword they were looking up. In the example below, it is easy to find documents that are related to different water management plans.

Conclusion

This post hopefully illustrates how different advanced search functionalities can improve search experience for the end user. Furthermore, it demonstrates that a Sitecore-based website can be set up and customized to include advanced search features, especially when paired with a powerful search platform such as Solr.