Understanding Sitecore SXA: Changes to Roles and Processes

Previous: Prescriptive, Yet Flexible


Two of SXA’s key benefits are improved project cadence and less reliance on development. Achieving these goals often means changes in roles and responsibilities.

Development doesn’t necessarily mean coding

With SXA, some of the implementation work that would otherwise be done in back-end code is now done in the Sitecore UI. That doesn’t mean that code is written in a Sitecore UI, but it does mean that some things that would have otherwise required code are now either done in, or supplemented by, activities in the Sitecore UI.

Once upon a time, the Sitecore UI largely insulated the person in the chair from technical “stuff”. Now, quite a bit of that technical stuff is managed in UI. Structuring components was once done entirely in code, now this is done largely in Sitecore. You’ll find yourself declaring element tags and CSS classes, creating data queries and using substitution tokens, and structuring things akin to models and markup. But just because it’s managed in UI doesn’t mean it doesn’t require a technical thinker.

Although much of the methodology shifts from code to configuration, developing functionality in SXA is conceptually more akin to development than content management. Just like in coding, an understanding of what can be done and how things work, leads to effective solutioning. Your technical staff is going to change where and how they do a lot of this work, and the big benefit is that many things that would otherwise have required a code deployment now just require a publish.

This will require a shift in thinking for both I.T. and Marketing. In the early days of CMS it was often hard for I.T. to accept that content management was now a production activity; now they must accept that more things that have been traditionally subjected to development protocols are now becoming production activities as well.

Front-End in the loop

The role of the front end developer isn’t just coding, and it isn’t just design. It’s some of both and other things besides. Since SXA is a framework that manages the methodology for developing both structure and style, the front-end developer’s work becomes part of the SXA flow.

Changes to HTML structure are done directly in SXA (or at times, in back-end code). This may be driven by the need for new renderings, or by imperatives the styling process. As wireframes and content are developed, the entire site (or portions of it) are exported to a ZIP file, where designers and front-end developers extend CSS and JavaScript and apply styling using their preferred tools. Sitecore’s Creative Exchange re-imports this zip file, detects changes to styling, and applies them to the system. The styling methodology is constrained by how the SXA framework operates (for example HTML structure and content can’t be modified, and existing class cannot be removed), and  SXA injects comments into the HTML to direct developers as appropriate.

If desired, teams can use “Creative Exchange Live” to fully automate the export/import loop. Creative Exchange can be triggered by a Continuous Integration server, integrating code changes into the main branch, and to test changes early and often.

Next: Which Way to Go?
Home: Understanding Sitecore SXA

Understanding Sitecore SXA: Prescriptive, Yet Flexible

Previous: Improved Project Cadence

Many marketers and technologists have found that their perspective on a large project can change rapidly, as the level of effort and learning curve become increasingly clear. The envisioned scope, schedule and budget are all threatened, as the imagined methodology and cadence meet reality.

SXA tackles this dilemma by providing a proven structure, framework, and methodology. The aim is to simplify processes, increase collaboration, shorten timelines, and smooth the path to success. Naturally, the maximum benefit is gained by a comprehensive adoption, but SXA can be used in an opt-in fashion, utilizing some of its features and replacing others with more conventional approaches.

By embracing all of SXA, organizations achieve the maximum benefit that they seek from a prescriptive, out-of-the-box framework. For many organizations, however, there are aspects to the architecture or build process that need a more custom approach.

Going All In

Adopting SXA to its fullest doesn’t mean giving up customization. Design customization is an essential part of an SXA build. Customizing CSS, building multiple themes, and extending the client-side structure are all common activities in an SXA build.

Page structure are actually more flexible with SXA than a typical conventional build. Content editors are able to drag-and-drop renderings, choose from more focused data sources, and adjust column widths. Also common is the use of Rendering Variants, to change the structure and appearance of components — without requiring code deployments!

SXA’s preferred project cadence solves a common pitfall. When design collides with content, it often becomes necessary to adjust, when styling designed for best casecontent collides with real world content. In the SXA model, these collisions are detected earlier, and remediated faster than with a conventional build.

In an all-out SXA implementation, the design/style/construct process is shortened, but changes from conventional expectations.

Wireframes are developed directly in Sitecore. They are exported as packages with HTML, CSS and script, organized in an orderly layered stack based on themes. Designers and front-end developers then style these wireframes, by extending and modifying the CSS and script (for the most part, without changing the HTML). Their work is imported back into Sitecore, where their theme(s) are applied to the site(s) that have already begun to take on content and structure.

This process can be iterative and branched. The export/style/import process can iterate, without necessitating radical changes to the existing work. In fact, Sitecore SXA provides “Creative Exchange Live”, that uses the gulp toolkit to bring design into a dev-ops model for continuous integration. Content editors continue to develop content and construct pages while the styling process iterates, shortening the project timeline and providing more real-world content to help refine the styling.

Multiple themes can be developed within or across sites, allowing the same components and structures to be presented differently simply by selecting from the different themes. The compounded power of reusable components with customizable themes and development-free customization, creates a force multiplier that can dramatically improves time-to-value.

Deep customization when needed

SXA ships with an impressive set of components that cover most of what the core of any site will need, and through the use of “rendering variants”, new renderings can be created without requiring coding.

Using these components out-of-the-box means (for the most part) working with the HTML as provided and styling entirely with CSS and script. An implementation can replace the HTML of all or some of these components and add new ones, but this requires requires a back-end development process more akin to a conventional build. Custom HTML is cut up and used as prototypes for c# developers to create new views, which replace default views or are registered in SXA as new components. Changes to the HTML require code deployments after a round trip through this back-end development process, which can slow concurrent content development.



Next: Changes to Roles and Processes

Home: Understanding Sitecore SXA

Understanding Sitecore SXA: Rapid Start, Smooth Execution

Previous: What is SXA?

Today’s marketing technology landscape has become a “field of dreams,” offering a dizzying array of platforms, technologies, and strategies. Marketers are eager to make their own dreams a reality, utilizing these tools to achieve the promise of true customer engagement.

Two things become quickly apparent.

• Actually living that dream means changing business as usual.
• Understanding how to execute is the difference between a dream and a nightmare.

Adopting a powerful technology like Sitecore can be overwhelming. A knowledgeable partner knows the landscape can guide a successful implementation, but a complex implementation can be a long and trying process.

By combining a suite of pre-built components and user-friendly tools that smooth the learning curve, SXA gets projects off to the right start and streamlines execution.

Throughout and beyond the initial project build, much of the work of modifying layout and even building new features is shifted to the Sitecore administrative interface, meaning many things that have historically relied on cumbersome code deployment processes can not be achieved with a mere publish.

Time-to-value is reduced, and concurrent team collaboration becomes a force multiplier rather than a series of tactical waves.

Next: Improved Project Cadence

Home: Understanding Sitecore SXA

Understanding Sitecore SXA: Improved Project Cadence

Previous: Rapid Start, Smooth Execution

Battle-scarred professionals know the stress and cost that can go with a fully bespoke implementation. Sitecore is an outstanding platform for creating truly exceptional experiences. But implementations can be drawn out, owing to the highly linear nature if a conventional build. Nervous stakeholders don’t see progress, and the seeming vacuum created by the isolated development process begs to be filled with new ideas and changes.

A classic linear build relies on handoffs of phases of the project: from user experience to information architecture to wireframing to front-end development to back-end development to content load to UAT. Changes and fixes require looking back farther and farther in the chain, leading to regression problems and costly rework.

SXA makes the process more parallel, and allows for continual adjustment and improvement that reduces the need for gated, painstakingly detailed requirements.

After primary envisioning, Sitecore itself becomes the hub around which the project revolves. Ongoing UX and content load begins immediately, using Sitecore’s wireframe tool. As visual design progresses, front-end developers develop themes that can be applied to already-loaded content in the wireframes, which become the publishable pages. Back-end developers build new components as needed, which are available in the toolbox immediately. Most bespoke component requirements can actually be created entirely within Sitecore and styled by back-end coders, all without requiring a code deployment.

Over the life of the project, stakeholders see ongoing progress, participants stay more engaged and collaborate better, issues are identified sooner, with less regressive remediation, and best practices lead to a deliverable that can be maintained and extended by anybody familiar with the framework.

Next: Prescriptive, Yet Flexible
Home: Understanding Sitecore SXA

Understanding Sitecore SXA

Sitecore Experience Accelerator (SXA) can be an absolute game-changer for how projects are envisioned, executed and maintained. Understanding how SXA will affect the design/build/maintain journey is key to knowing when to adopt. Just like in an auto race, knowing when to hit the accelerator can make the difference between success and disaster.

This seven-part series will examine the what-and-why of SXA, and uncover the impact SXA can have on marketing effectiveness.

Why SXA?

If you’re facing a new implementation for the first time, or you’ve been battle-scarred from a past rocky implementations, there’s a certain allure to an out-of-the-box solution, built on best practices, containing a swath of pre-built capabilities, with a prescriptive implementation process.
Learn about SXA’s promise and what it could mean for you.
Read more...

What is SXA?

SXA is a Sitecore-supported framework, toolbox and methodology that helps projects get started faster, develop more smoothly, and deliver results reliably. Learn more about how SXA helps overcome many of the conventional hurdles faced by Sitecore project implementers.
Read more...

Rapid start, smooth execution

Adopting a powerful technology like Sitecore can be overwhelming. Implementations are rocky, solutions become unmaintainable, and the high-return “phase 2” features never come to pass. Learn how SXA’s prescriptive, best-practice methodology and user-friendly tools can smooth the learning curve, get projects off to the right start, and streamline execution.
Read more...

Flatter, faster cadence

Every Sitecore project is unique. Some large, some smaller. Some stand-alone, some multisite. Some complex, some straightforward. Languages, search, media, seo, visual design — any of these can raise the complexity bar. Learn how SXA can lower the barrier to entry, speed time to value, and enable continuous improvement.
Read more...

Prescriptive, but flexible

Digital marketers and technologists that have lived through (or are facing up to) a complex project, the unknowns of proper execution loom large. Faced with unknown complexity, the idea of a highly prescriptive methodology can be a welcome relief. That may feel confining, but SXA allows a mix-and-march approach that allows a given project to adopt all or just some of SXA’s processes. Learn how SXA allows the hard things to be hard, while keeping the simple things simple … and makes some of those hard things simpler than you thought.
Read more...

Nuances in process and responsibilities

When moving into an SXA mindset, in addition to changes in methodology and process, be prepared for roles to be redefined or at least shift a bit. Learn more about how disciplines and processes may shift when adopting SXA as an implementation framework.
Read more...

Choosing a path

Conventional build or SXA? Marketers and technologists preparing for a new site build in Sitecore have more choices than ever before. SXA offers a real alternative to the classic build approach, bringing with it both advantages and challenges.
Read more...

Zip code data in Sitecore

---

The source code and documentation for this solution are available on GitHub. Download

---

Good old postal Zip Codes. Not a very exciting subject, but it seems like every year or two, I run into a solution that requires access to a zip code database.

There are several commercial services that provide extensive zip code data, but there is at least one free database available (https://boutell.com/zipcodes/) that includes a decent amount of data, including coordinates, city and state, and time zone.

Latitude and longitude can be useful if for example you needed to put an "approximate" pin in a map.

We recently ran into a situation where we needed to know the visitor's time zone. Sitecore GeoIP data includes zip codes, but not time zones. All I need is to wire that up to a zip code database, and I'm all set. (And before you quibble over the accuracy, don't. I know it's not perfect; I think of this as a "good enough" solution).

So I set up a solution to provide Sitecore with an API for looking up zip codes. I started with a few goals:

• I want to be able to use this in any Sitecore solution.,
• I don't want to use SQL. It's always administrative and deployment hassle to use custom SQL tables.
• I don't want to impose a schema on every application that uses this. Sure, that free zip database is fine for what I need now, but others may have more detailed data they'd like to use.
• I want to use a swappable provider so other applications can change how the data is imported, where it is stored, and/or how it is queried.
• For my default provider, I want it to "just work". I drop the file into a folder, and my Sitecore app has access to the data (well, I did end up also needing to add a mongo connection string to the connectionstrings.config file).

I decided to use MongoDB to store the data. Once I have a connection string, I can create collections and add data with any schema I want, without bugging the SQL admins. I also added to add a caching layer. I'm probably going to access this data from rules and such, and I want it to be zippy-quick.

The data flow looks like this:

The idea is, the operational data stored in MongoDB, and accessed through a caching layer at runtime. At application start (and via an administrative interface), the data file date is compared to the last time the data was imported, and if the file is newer, it is re-imported.

Installing the module

Install the update package in your Sitecore application. When Sitecore starts, it will populate a MongoDB database with data from a provided zip code document located in App_Data. This file is sourced from https://boutell.com/zipcodes/.

Whenever this file is updated, it will be reloaded the next time Sitecore starts.

Add a connection string to your ConnectionStrings.config file with the name you'd like to use for your Mongo database. For example

<add name="zipinfo" connectionString="mongodb://localhost:27017/zipinfo" />

If you want to use a separate mongo database for each Sitecore instance sharing a common Mongo server, change the connectionString e.g.
connectionString="mongodb://localhost:27017/myapp_zipinfo"

The update package will place a copy of the data file in your App_Data folder. You can relocate this to the Sitecore data folder if you desire.

Using the module

The module exposes a "manager" static class (ZipInfo.ZipInfoManager) with static methods like Get(int zipCode) to access the data. I won't get into all the methods here (see the documentation), but there are methods for both retrieve/update and cache management operations.

The update package will also install a utility at /sitecore/admin/zipinfo.aspx that'll allow you to query the database, manage the cache, and re-import the data.

The module exposes a provider class that can be swapped out with your own provider. If you have more detailed data in a a csv file, you can simply inherit from the default provider, create your own POCO class, and override the LoadRecord method that maps fields on the csv line to the POCO. If you need a different method for loading the data rather than reading it from a csv file, override the Load method. If you don;t want to use mongo, you can replace the entire provider by creating a class that implements IZipInfoProvider. More information about the provider is available in the docs.

---

The source code and documentation for this solution are available on GitHub. Download

---

Content Indexing vs Site Search

I've had this conversation so many times, I thought I'd capture it here once and for all.

There is a vast difference between content indexing and site search. The following discusses these differences. This is not exhaustive; there are finer nuances that I’ll skip over in order to keep focused on the key concepts.

Content Indexing

Content indexing is the act of storing selected fields of Sitecore content items into a separate index, so that content items can be retrieved rapidly by code. Examples of this are the search box Sitecore uses for item buckets, or a custom rendering that “facets” content e.g. outputs links to every item where “Georgia” is selected in a “Home state” field.

• Indexes are created by copying raw item data into the index, typically when the item is saved or published.
• Content indexing is a “data-oriented” operation e.g. a lookup in an index finds an match of content in a field. 
• A content index has no concept of pages, and does not have any ability to rank on such things as link frequency. 
• Content Indexing is absolutely required for Sitecore to function. 
• Sitecore implements content indexing “out of the box”, using Lucene by default, with configurable support for Solr in scaled enterprise environments. 

Site Search

Site search is the act of indexing the content of entire viewable pages, so that whole pages can be found using “free text” search. An example of this is a site visitor entering a few words in a search box and getting back a page of ranked results, akin to a Google search.

• Indexes are created by “crawling” the site e.g. code uses http requests to pull every page of the site, storing the content in its index, and examining the links on in the page to find more pages to crawl.
• Site search is a “free text” operation, e.g. a lookup considers all of the visible content of a page.
• A good site search tool ranks results based on things like semantics e.g. content in <h1> tags will rank higher than body text, or linking e.g. pages with more inbound links will rank higher.
• A site search solution is only necessary if you want visitors to be able to “free text” search the site e.g. the site has a “search box”. 
• Sitecore does not implement free-text page search “out of the box”.

Why the distinction is important

Any given page of a Sitecore site may have visible page content derived from many content items. Therefore, out-of-the-box content indexing is not an appropriate solution for site search.

Moreover, a good “free text” search experience requires that the results be well ranked. Consider when you do a Google search. Google isn’t simply returning a flat list of every page that contains your search terms, instead, it is using highly sophisticated ranking algorithms to present the results you are most likely to want first. If you’re familiar with SEO principles, you know that there are many factors that influence rank far beyond the simple content of the page.

Of course there is some overlap. A good site search tool can also include "hard data" in the form of metadata, so that search results can be "faceted". This allows the visitor to "filter" results based on date, geography, product line, or any other "field oriented" data that you include in the page metadata.

We've already deployed Solr. Why can't we use that for site search?

In theory, there is a way to leverage a Solr index to do free text search. This is not a simple matter of “configuration”, but rather, requires extensive coding. The general idea is you build a scheduled processor that programmatically loads every page of the site (via an http request) so it can get the entirety of the content on a given page. It puts that content into a “computed field” of a Solr index. Then, custom “search box” code can search that “computed field” for occurrences of that content. There are a drawbacks to this approach:

• It is not implemented out of the box.
• The ranking of search is either non-existent, or at least far short of the ranking quality of a true crawler.

[edited to correct my error about Coveo]

There are “off the shelf” tools that combine the concepts of content indexing and site search.

• Coveo is an excellent commercial product that uses a proprietary indexing mechanism, with conventional "content indexing" and also crawling. It can index both entire pages and content items. It comes with value-added tools for rapid deployment of faceted search features, and also adds some ranking capabilities, including the ability to manually tweak search ranking. It comes in on-premises, cloud, and a hobbled “free” version. It is arguably the “least effort” solution to implement, since it is very "Sitecore aware" out of the box.
• There are lots of free and commercial solutions. For example, Arke’s SDK includes a “computed search” module. uses configured field and template types to inject page content into a Solr index. 

There are other “off the shelf” solutions that provide excellent free text search experiences that do not rely on Solr. Most of these have evolved to cloud-hosted rather than on-premises solutions. Google site search and Amazon cloud search are leaders in this space, and Coveo had a cloud edition, but there are many services available. Using one of these services would still require coding, but it would be pure “integration” coding, not an attempt to build a full blown crawler.

In the absence of an “off the shelf” solution, you could build a home-grown Solr-based crawler. It’d require significant time and effort, only to yield a pretty poor user experience due to the lack of any sophisticated ranking.