Optimizely Articles / Blogs / Perficient https://blogs.perficient.com/tag/optimizely/ Expert Digital Insights Tue, 06 Jan 2026 08:32:35 +0000 en-US hourly 1 https://blogs.perficient.com/files/favicon-194x194-1-150x150.png Optimizely Articles / Blogs / Perficient https://blogs.perficient.com/tag/optimizely/ 32 32 30508587 Rendering HTML Content in Optimizely Spire: Correct Handling for CMS and Custom Properties https://blogs.perficient.com/2026/01/05/rendering-html-content-in-optimizely-spire-correct-handling-for-cms-and-custom-properties/ https://blogs.perficient.com/2026/01/05/rendering-html-content-in-optimizely-spire-correct-handling-for-cms-and-custom-properties/#comments Tue, 06 Jan 2026 04:46:23 +0000 https://blogs.perficient.com/?p=389344

When using Optimizely Commerce Spire with React 18 or later, developers frequently encounter hydration issues—pages render blank or React shows hydration warnings. This typically occurs when the HTML rendered on the server does not match what React expects on the client.

This blog covers:

  • Why hydration issues occur after upgrades
  • The difference between CMS content and custom properties
  • How to use parse, parserOptions, and transformContentHtml correctly
  • Best practices for Spire projects

Why Hydration Issues Occur

React 18 introduced stricter hydration checks. Hydration is the process by which React attaches event listeners and state to server-rendered HTML. If the HTML structure differs between the server and the client, React logs warnings or hydration can fail completely.

In Optimizely:

  • Existing content (created before the upgrade) may contain HTML structures such as <html>, <body>, and <title> tags.

Before upgrade

  • After the upgrade, when you re-save the text in Optimizely Admin, these extra tags (<html>, <body>, <head>) are automatically removed.

Note: If you do not re-save manually, the old content will still retain these tags, resulting in inconsistent HTML between the server and the client.

After upgrade

This mismatch causes blank pages or hydration warnings since React expects a consistent DOM structure.

Hydation error

CMS Content vs Custom Properties

Spire accepts HTML content from two main sources:

  • CMS content: Standard pages and widgets from the CMS. These typically contain clean HTML fragments suitable for direct parsing.
  • Custom properties: Data from the admin panel for Product, Category, Warehouse, Brand, and Location. These often include legacy HTML or encoded tags, which can cause mismatches during hydration.

Rule of thumb:

  • CMS content → parse directly
  • Custom properties → normalize first with transformContentHtml, then parse

Correct Rendering Approach

For CMS content

{parse(category.htmlContent, parserOptions)}

For custom properties

{parse(transformContentHtml(category.htmlContent), parserOptions)}

This ensures that CMS content is rendered as is, while custom property content is cleaned up before rendering.

Utility Functions Overview:

  • transformContentHtml
    • Import: 
      import transformContentHtml from "@insite/client-framework/Common
    • Purpose:
      • Detects full HTML documents and extracts <body> content.
      • Encodes special characters where required.
      • Normalizes legacy HTML so that it is safe and compatible with React hydration.
  • parse
    • Library: html-react-parser
    • Purpose:
      • The parse function converts HTML strings into React elements.
      • React cannot render raw HTML strings directly, so parsing into elements is the correct approach to display dynamic HTML content.

  • parserOptions

    • Import:

      import { parserOptions } from "@insite/client-framework/Common
    • Purpose:
      • Defines how HTML tags and attributes are transformed or sanitized during parsing.
      • Removes unsafe attributes.
      • Allows customization of tag and attribute replacements.

Best Practices

  • If you only have 10–15 pages, re-save them in Optimizely Admin to remove outdated tags.
  • Always choose the appropriate parsing strategy depending on the content source (CMS vs custom properties).
  • Validate the content of custom properties before rendering to prevent inconsistent HTML and hydration issues.

 

Conclusion

  • Mismatched HTML structures cause hydration problems in React 18 when using Optimizely Spire.
  • For CMS content, use parse with parserOptions.
  • For custom properties, normalize with transformContentHtml before calling parse.
  • This approach avoids blank pages after upgrades and ensures reliable, accurate rendering in Spire projects.
]]> https://blogs.perficient.com/2026/01/05/rendering-html-content-in-optimizely-spire-correct-handling-for-cms-and-custom-properties/feed/ 2 389344 Optimizely Mission Control – Part III https://blogs.perficient.com/2025/09/13/optimizely-mission-control-part-iii/ https://blogs.perficient.com/2025/09/13/optimizely-mission-control-part-iii/#comments Sat, 13 Sep 2025 12:34:23 +0000 https://blogs.perficient.com/?p=385025

In this article, we will cover all the remaining actions available in Mission Control.

Base Code Deploy

The Optimizely team continuously improves the platform by introducing new features and releasing updated versions. To take advantage of these enhancements and bug fixes, projects must be upgraded to the latest version. After upgrading the project, it needs to be deployed to the appropriate environment. This deployment is carried out using the “Base Code Deploy” option in Mission Control.

How to deploy the Base Code

  • Log in to Mission Control.

  • Navigate to the Customers tab.

  • Select the appropriate Customer.

  • Choose the Environment where you want to deploy the base code changes.

  • Click the Action dropdown in the left pane.

  • Select Base Code Deploy.

  • A pop-up will appear with a scheduler option and a dropdown showing the latest build version.

  • Click Continue to initiate the deployment process.

  • Once the process completes, the base code is successfully deployed to the selected environment.

Reference: Base Code Deploy – Optimizely Support

Extension Deployment

There are many customizations implemented according to project requirements, and these are developed within the extension project following Optimizely framework guidelines. To make these changes available in the environment, we need to deploy the extension project code. This can be done using the Extension Deployment option available in Mission Control.

Deploy Extension Code

  • Log in to Mission Control.

  • Navigate to the Customers tab.

  • Select the appropriate Customer.

  • Choose the Environment where you want to deploy the extension code.

  • Click the Action dropdown in the left pane.

  • Select Extension Deployment.

  • A pop-up will appear with an optional scheduler and a dropdown showing available extension build versions.

  • Select the desired extension version to deploy.

  • Click Continue to initiate the deployment process immediately.

  • Once the process completes, the extension code is successfully deployed to the selected environment.

Reference: Extension Deployment – Optimizely Support

Production User Files Sync

In any project, there are numerous user files—especially images—which play a crucial role in the website’s appearance and user experience. During development, it’s important to keep these files synchronized across all environments. Typically, the files in lower environments should mirror those in the production environment. Since clients often update files directly in production, the “Production User Files Sync” option in Mission Control becomes extremely useful. It allows developers to easily sync user files from production to lower environments, ensuring consistency during development and testing.

How to sync production user files

  • Log in to Mission Control.

  • Navigate to the Customers tab.

  • Select the appropriate Customer.

  • Choose the lower environment where you want to sync the user files.

  • Click the Action dropdown in the left pane.

  • Select User File Sync from the list of available options.

  • A pop-up will appear with an optional scheduler and a Source Environment dropdown containing all environments available for the selected customer.

  • Select Production as the source (or any environment as required), then click Continue to start the sync process.

  • Depending on the size of the user files and network parameters, the process might take several minutes to complete.

Reference: Production User Files Sync – Optimizely Support

Production Database Sync

This option allows you to synchronize data from the production environment to a lower instance.
Note: Data cannot be synced from a lower instance back to production.

Critical Requirements

  • Matching Website Keys
    • The website keys in both the production and target environments must match.
    • If they do not, the site may experience a startup failure and become unstable.

  • Version Compatibility

    • The target environment must be running on a version that is equal to or newer than the source (production) version.

    • Both source and target environments must be on one of the last three supported long-term versions, or their corresponding short-term support versions.

    • If version requirements are not met, the sync process will fail.

  • Data Loss Warning

    • This is a destructive operation—it will overwrite data on the target (lower) environment.

    • Ensure that no critical or important data exists in the sandbox or lower instance before initiating the sync.

The Production Sync option does not replicate all data, but it does synchronize several key components. Below is the list of data that gets synced:

Product Data

  • Product settings (e.g., ERP Managed, Track Inventory, Quote Required)

  • Attribute values

  • Category assignments

  • Product content (metadata and rich content)

  • Product specifications

  • Child variants

  • Pricing and cost

  • Product number and URL segment

  • Warehouse inventory (stock levels)

  • Shipping information

Category Data

  • Category details (name, description)

  • Category hierarchy

  • Assigned products

  • Category content (metadata and content)

  • Attribute values

CMS Content

  • CMS customizations made via out-of-the-box widgets (non-code changes)

  • Variant page customizations and display rules

Additional Data

  • Attribute types and values

  • Variant types

  • Customer records

  • Website users

Data Not Synced from Production to Sandbox

The following areas are excluded from the Production Sync process and remain unchanged in the target sandbox environment:

  • System Configuration
  • Integration Job Settings
  • Admin & User Data

    • Exceptions

      • If a production admin user has made changes to data being synced (like CustomerOrders, Content, etc.), that admin user is also synced to the sandbox.

      • Admin user roles are also synced to preserve permission context.

      • To prevent role duplication:

        • All sandbox roles are appended with -1.

        • Production roles retain their original names.

      • If a matching admin user exists in both environments:

        • The production user and roles are retained.

        • Sandbox-only users receive roles with the -1 suffix.

  • Logs and Cache

Sync production data

  • Log in to Mission Control.

  • Navigate to the Customers tab.

  • Select the appropriate Customer.

  • Choose the lower environment where you want to sync the production data.

  • Click the Action dropdown in the left pane.

  • Select Production Database Sync from the list of available options.

  • A pop-up will appear with:

      • An optional scheduler, and

      • A Source Environment dropdown (select the production environment).

  • Click Continue to initiate the sync process.

  •  This is a large-scale data transfer operation. The sync process may take several minutes to complete, depending on the volume of data.

Note: Optimizely does not provide a rollback option for this process. Once the deployment is complete, any changes—such as modifications to stored procedures or database scripts—restored it.

Reference: Production Database Sync – Optimizely Support

]]> https://blogs.perficient.com/2025/09/13/optimizely-mission-control-part-iii/feed/ 1 385025 Optimizely Mission Control – Part II https://blogs.perficient.com/2025/08/18/optimizely-mission-control-part-ii/ https://blogs.perficient.com/2025/08/18/optimizely-mission-control-part-ii/#respond Mon, 18 Aug 2025 07:02:45 +0000 https://blogs.perficient.com/?p=384870

In this section, we focused primarily on generating read-only credentials and how to use them to connect to the database.

Generate Database Credentials

The Mission Control tool generates read-only database credentials for a targeted instance, which remain active for 30 minutes. These credentials allow users to run select or read-only queries, making it easier to explore data on a cloud instance. This feature is especially helpful for verifying data-related issues without taking a database backup.

Steps to generate database credentials

  1. Log in to Mission Control.

  2. Navigate to the Customers tab.

  3. Select the appropriate Customer.

  4. Choose the Environment for which you need the credentials.

  5. Click the Action dropdown in the left pane.

  6. Select Generate Database Credentials.

  7. A pop-up will appear with a scheduler option.

  8. Click Continue to initiate the process.

  9. After a short time, the temporary read-only credentials will be displayed.

 

Once the temporary read-only credentials are generated, the next step is to connect to the database using those credentials.

To do this:

  1. Download and install Azure Data Studio
    Download Azure Data Studio

  2. Open Azure Data Studio after installation.

  3. Click “New Connection” or the “Connect” button.

  4. Use the temporary credentials provided by Mission Control to connect:

    • Server Name: Use the server name from the credentials.

    • Authentication Type: SQL Login

    • Username and Password: As provided in the credentials.

  5. Once connected, you can execute SELECT queries to explore or verify data on the cloud instance.

 

For more details, refer to the official Optimizely documentation on Generating Database Credentials.

For Part I, visit: Optimizely Mission Control – Part I

]]> https://blogs.perficient.com/2025/08/18/optimizely-mission-control-part-ii/feed/ 0 384870 How to Write Media Queries in Optimizely Configured Commerce (Spire) https://blogs.perficient.com/2025/08/05/how-to-write-media-queries-in-optimizely-configured-commerce-spire/ https://blogs.perficient.com/2025/08/05/how-to-write-media-queries-in-optimizely-configured-commerce-spire/#comments Wed, 06 Aug 2025 04:39:35 +0000 https://blogs.perficient.com/?p=385710

Media queries are essential for modern websites. They enable responsive design by allowing your site or UI to adapt seamlessly across different device sizes. In this blog, we’ll explore how to implement media queries in Optimizely Spire and how to update or customize breakpoints to suit your design needs.

Let’s get started!

Setting Up Breakpoints

First, we’ll define breakpoints based on our style guide. Breakpoints help your website adjust its layout depending on the screen size, such as mobile, tablet, or desktop.

In Optimizely Spire, breakpoints are defined within the theme configuration file. To update these breakpoints in the base code, you need to create a Start.tsx file—if it hasn’t been made already.

Path: modules/blueprints/CustomBlueprint/src/Start.tsx

Where to Place Breakpoint Configuration

Place the breakpoint configuration within either the setPreStyleGuideTheme or setPostStyleGuideTheme functions. These functions allow you to customize the theme before or after the default style guide is applied.

This setup ensures that your custom breakpoints are recognized and used consistently throughout your application.

Below is the configuration structure for setting custom breakpoints in Optimizely Spire:

Breakpoint Configured commerce

Understanding the Breakpoint Configuration

To make your site responsive, you define breakpoints—specific screen widths where your layout should adapt. Here’s what each part of the configuration means:

  • Keys – Represent screen size labels such as:

These are shorthand names for different device sizes:

    • xs – Extra small (e.g., small phones)
    • sm – Small (e.g., larger phones)
    • md – Medium (e.g., tablets)
    • lg – Large (e.g., small laptops)
    • xl – Extra large (e.g., large desktops)

  • Values – Minimum Widths

These define when each screen size category starts:

    • xs starts at 0px
    • sm starts at 576px
    • md starts at 768px
    • lg starts at 992px
    • xl starts at 1200px

  • Max Widths – Content Limits

These define the maximum width the content area can grow to at each breakpoint. Even if the screen is wider, the content won’t stretch beyond these limits (example: 1140px for xl).

Think of it like this:

  • On a phone → small screen → use xs styles
  • On a tablet → medium screen → use md styles
  • On a laptop or desktop → big screen → use lg or xl styles

Creating Media Queries in a Standardized Way

To create media queries in Optimizely Spire, we rely on the breakpoint configuration defined earlier. This ensures consistency across the application and simplifies responsive design.

How It Works

Behind the scenes, Spire uses a utility called breakpointMediaQueries to convert standardized media query definitions into browser-readable CSS.

Utility Location:  modules\mobius\src\utilities\breakpointMediaQueries.ts

This utility helps generate clean and consistent media queries based on your defined breakpoints.

Available Media Query Types:

Here are three types of media query options available:

  • min – Applies styles when the screen is at or above a certain width.
  • max – Applies styles when the screen is at or below a certain width.
  • minMax – Applies styles between two specific widths.

Default Media Query Structure

Here’s what a typical media query definition looks like using this utility:

Media query structure configured commerce

Now let’s see how this media query utility works with min, max, and minMax.

  • min

The min-width media query structure will be as follows:

Min Width media query configured commerce

 Example: To apply styles for min-width: 576px, insert your CSS code in the appropriate section.                                               Min Width media query example configured commerce

Similarly, if you want to apply CSS for min-width: 768px, just replace the respective null with your CSS code.

  • max

The max-width media query structure will be as follows:

Max Width media query configured commerce

Example: To apply styles for max-width: 575px, insert your CSS code in the appropriate section.Max Width media query example configured commerce

Similarly, if you want to apply CSS for max-width: 767px, just replace the respective null with your CSS code.

  • minMax

The minMax media query structure will be as follows:minMax Width media query example configured commerce

Example: To apply styles between min-width: 576px and max-width: 767px, insert your CSS code in the appropriate section.minMax Width media query example configured commerce

 

Similarly, if you want to create media queries for other screen sizes, follow the same approach as described above.

You can also define multiple CSS rules as shown in the examples below.

With Multiple Css Option configured commerce

Conclusion

Creating responsive layouts doesn’t have to be complicated or repetitive. A utility like breakpointMediaQueries helps you apply consistent styling logic throughout your application. Whether you use a mobile-first (min), desktop-first (max), or range-based (minMax) approach, this system lets you apply styles exactly where they’re needed.

By simplifying the media query logic, your code becomes easier to read and maintain, so you can focus more on design and less on repetitive code. Choose the approach that best fits your project, and let your breakpoints handle the rest.

 

]]> https://blogs.perficient.com/2025/08/05/how-to-write-media-queries-in-optimizely-configured-commerce-spire/feed/ 1 385710 Optimizely Mission Control – Part I https://blogs.perficient.com/2025/08/04/optimizely-mission-control-part-i/ https://blogs.perficient.com/2025/08/04/optimizely-mission-control-part-i/#comments Mon, 04 Aug 2025 13:19:29 +0000 https://blogs.perficient.com/?p=384712

Optimizely provides powerful tools that make it easy to build, release, and manage cloud infrastructure efficiently.

Optimizely Mission Control Access

To use this tool, an Opti ID is required. Once you have an Opti ID, request that your organization grants access to your user account. Alternatively, you can raise a ticket with the Optimizely Support team along with approval from your project organization.

Key Actions

This tool provides various essential actions that can be performed for managing your cloud environments effectively. These include:

  • Restart Site

    • Restart the application in a specific environment to apply changes or resolve issues.

  • Database Backup

    • Create a backup of the environment’s database for debug purposes.

  • Generate Database Credentials

    • Generate secure credentials to connect to the environment’s database.

  • Base Code Deploy

    • Deploy the base application code to the selected environment.

  • Extension Deployment

    • Deploy any custom extension changes.

  • Production User Files Sync

    • Synchronize user-generated files (e.g., media, documents) from the production environment to lower environments.

  • Production Database Sync

    • Sync the production database to another lower environment (such as a sandbox) to sync up data.

Let’s walk through each of these actions step by step to understand how to perform them.

Restart Site

We can restart the site using the Mission Control tool. This option is handy when a website restart is required due to configuration changes. For example, updates to the storage or search provider often require a restart. Additionally, if an integration job gets stuck for any reason, the ability to restart the site becomes very helpful in restoring normal functionality.

How to restart the website

  1. Log in to Mission Control.

  2. Navigate to the Customers tab.

  3. Select the appropriate Customer.

  4. Choose the Environment where the restart is needed.

  5. Click on the Action dropdown in the left pane.

  6. Select Restart Site from the list.

  7. A pop-up will appear where you can either schedule the restart or click Continue for an immediate restart.

 

Reference: Restart Site – Optimizely Support

Database Backup

This is another useful feature available in Mission Control.

Using this option, we can take a backup from the Sandbox or Production instance and import it into the local environment. This helps us debug issues that occur in Sandbox or Production environments.

The backup file is generated with a .bacpac extension.

Steps to take a backup

  1. Log in to Mission Control.

  2. Navigate to the Customers tab.

  3. Select Database Backup from the list.

  4. A pop-up will appear prompting for a scheduled backup time.

  5. Set Skip Log to False to minimize the backup size.

  6. Click Continue and wait for the process to complete.

  7. Once finished, click on the provided link to download the backup file.

 

Reference: Database Backup – Optimizely Support

Stay tuned for the next blog to explore the remaining actions!

]]> https://blogs.perficient.com/2025/08/04/optimizely-mission-control-part-i/feed/ 1 384712 Implementation of Custom Tables in Optimizely Configured Commerce https://blogs.perficient.com/2025/07/08/implementation-of-custom-tables-in-optimizely-configured-commerce/ https://blogs.perficient.com/2025/07/08/implementation-of-custom-tables-in-optimizely-configured-commerce/#respond Tue, 08 Jul 2025 06:48:06 +0000 https://blogs.perficient.com/?p=383515

In many B2B commerce implementations, the default features provided by Optimizely Configured Commerce may fall short, particularly when it comes to managing or storing custom data. This blog will outline how to create and work with custom database tables within the platform, ensuring flexibility without altering core system components.

What Are Custom Tables?

Custom tables are user-defined database tables used to hold additional information about products, customers, orders, or other business-specific data. They allow developers to expand the platform’s capabilities without interfering with the existing database schema, which supports better maintainability and easier upgrades.

Why Create Custom Tables?

Here are the key reasons to implement custom tables in Optimizely Configured Commerce:

  • Storing metadata or attributes that don’t naturally fit into existing system tables
  • Supporting business processes that require unique data structures
  • Keeping the core schema that clean while enabling platform customization

Steps to Implement a Custom Table

Creating a custom table involves adding a new table via a SQL script and configuring it to run automatically using the Optimizely bootstrapper.

  1. Set Up the Project Structure:
    Begin by creating a folder named DatabaseScript at the root of your Extension project.
    Db Structure
  2. Follow Naming Conventions:
    Use the following format for naming your SQL script files: YYYY.MM.DD.SS.DescriptiveName.sql

    • YYYY = year
    • MM = month
    • DD = day
    • SS = sequence number for that day
      This convention ensures scripts run in the correct order and version control is maintained.
  3. Mark Script as Embedded Resource:
    To ensure the bootstrapper can detect and execute your script, set its Build Action to Embedded Resource in the properties panel.
    Script Property

Example: Creating a Custom Table for Product Data

Let’s say you want to store extra product details. You could create a table called ProductExtensions using a script named 2025.06.03.01.Table_ProductExtension.sql. To proceed, this file should be added to the DatabaseScript folder and marked as an embedded resource with the following content:
Script

Table Structure

Once you execute the script, the system creates a custom table named Extension.ProductExtension in the database, as shown below:

Guidelines for Custom Table Design

  • All custom tables, views, and stored procedures must exist under the Extensions schema.
  • You can modify and load data into other schemas, but DDL operations are restricted to the Extension schema.
  • Each custom table must include a primary key field named Id of type uniqueidentifier with a default of newsequentialid().
  • Include audit fields like CreatedOn, CreatedBy, ModifiedOn, and ModifiedBy, all non-nullable and set with proper defaults.
  • Add indexes on commonly queried fields like ErpNumber and Id.
  • You can define foreign key relationships to dbo schema tables, since the Extensions user has permission to reference them.

Script Execution and Bootstrapper Behaviour

When the application starts, the bootstrapper checks for new database scripts and runs them. It also logs each executed script in the DatabaseScript table. To re-execute a script, however, you must delete both the custom table and its entry in the DatabaseScript table. On the next application start, the system will execute the script again and relog it.

Conclusion

Custom tables in Optimizely Configured Commerce offer a powerful way to tailor the platform to your organization’s unique data and functionality needs, all without compromising the integrity of the core system

 

Reference: Create custom tables with an entity and WebApi

]]> https://blogs.perficient.com/2025/07/08/implementation-of-custom-tables-in-optimizely-configured-commerce/feed/ 0 383515 Content Compliance Without the Chaos: How Optimizely CMP Empowers Financial Services Marketers https://blogs.perficient.com/2025/05/22/content-compliance-without-the-chaos-how-optimizely-cmp-empowers-financial-services-marketers/ https://blogs.perficient.com/2025/05/22/content-compliance-without-the-chaos-how-optimizely-cmp-empowers-financial-services-marketers/#respond Thu, 22 May 2025 15:54:21 +0000 https://blogs.perficient.com/?p=381836

In financial services, content isn’t just about telling your story — it’s about telling it right. Every blog post, product update, or social post is a potential compliance risk if not handled carefully. Regulatory bodies like FINRA, SEC, and GDPR aren’t known for leniency, and the cost of a misstep can be significant — fines, reputational damage, and operational headaches.

For many firms, keeping up with compliance while managing complex content workflows feels like juggling chainsaws. Manual processes, endless email chains, and disconnected tools only make it worse.

 

But it doesn’t have to be this way.

 

The Compliance Content Bottleneck in Financial Services

Content creation in financial services isn’t just Marketing’s job. Legal, Compliance, Risk, and other teams are deeply involved in every asset. This creates unique challenges:

  • Version control nightmares – multiple drafts floating in email chains.
  • Lack of audit trails – “Who approved this? When? Under what policy?”
  • Slow go-to-market – regulatory reviews stall time-sensitive campaigns.
  • Inconsistent messaging – especially across web, email, and social.
  • Siloed collaboration – Marketing, Legal, and Compliance working in parallel, not together.

 

This tangled process isn’t just inefficient – it’s risky.

 

How Optimizely CMP Brings Order to Compliance Workflows

Optimizely’s Content Marketing Platform (CMP) is built to untangle this mess. It provides a single, governed workspace where content moves through structured workflows, ensuring compliance without sacrificing speed or collaboration.

 

Here’s how it helps:

  1. Governed Workflows Built for Compliance

Define step-by-step approval flows that align with your regulatory requirements. Ensure every piece of content gets the right eyes on it — from Legal to Compliance to final publishing.

 

  1. Audit Trails & Version History

CMP tracks every change, comment, and approval, giving you a clear record of who did what, when. Perfect for audits, internal reviews, or when you just need to prove due diligence.

  1. Role-Based Access Controls

Not everyone should edit, approve, or publish. CMP enforces role-based permissions to ensure compliance is baked into the process, not left to chance.

  1. Content Calendars & Scheduling

Align your campaigns with compliance review timelines. Plan content in advance, avoid last-minute scrambles, and ensure every asset goes live with full approval.

 

  1. Consistency Through Reuse & Templates

Maintain brand and regulatory consistency with reusable content blocks and templates. Reduce errors and accelerate content creation.

 

A Real-World Example: Financial Product Launch with CMP

Imagine launching a new investment product. With CMP:

 

  1. Marketing drafts content in the platform.
  2. Legal and Compliance receive automatic review tasks in a structured workflow.
  3. Feedback is consolidated directly in CMP, avoiding scattered emails.
  4. Final approvals are logged and recorded for audit purposes.
  5. Content is published across channels, using the same approved version.

All tracked. All compliant. All without chaos.

 

Beyond Compliance: Business Benefits That Matter

While compliance is critical, CMP delivers broader value:

  • Faster time to market for campaigns and updates.
  • Reduced risk of fines and penalties.
  • Stronger collaboration between teams.
  • Improved content quality and consistency.
  • Better customer experience with accurate, timely content.

 

Why Optimizely CMP Stands Out for Financial Services

  • Seamless integration with Optimizely’s DXP for content delivery.
  • Extensible workflows that can adapt to industry-specific compliance needs.
  • Proven success with other highly regulated industries like healthcare and insurance.
  • Scalable governance that grows with your content demands.
  • Content Compliance as a Competitive Advantage

In a world where trust and accuracy are non-negotiable, getting content compliance right isn’t just about avoiding fines — it’s about building credibility.

 

Optimizely CMP turns content governance into a competitive advantage, empowering financial services firms to deliver compliant, high-quality content at scale.

 

How Perficient Can Help

At Perficient, we specialize in helping financial services organizations streamline content workflows, implement compliance-ready CMP solutions, and get the most out of their digital experience investments.

]]> https://blogs.perficient.com/2025/05/22/content-compliance-without-the-chaos-how-optimizely-cmp-empowers-financial-services-marketers/feed/ 0 381836 Opal: Optimizely’s AI Assistant Powering Content, Personalization, and Workflow Automation https://blogs.perficient.com/2025/05/22/opal-optimizely-ai-marketing-assistant/ https://blogs.perficient.com/2025/05/22/opal-optimizely-ai-marketing-assistant/#comments Thu, 22 May 2025 14:39:44 +0000 https://blogs.perficient.com/?p=381808

Overview

Opal is Optimizely’s AI assistant designed to accelerate and enhance the entire marketing workflow. Integrated natively across OptimizelyOne, Opal helps teams ideate, plan, generate, manage, and optimize content more intelligently and efficiently. This post outlines key features, current capabilities, upcoming enhancements, and how Opal fits into the broader AI powered content lifecycle.

Opal leverages advanced natural language processing (NLP) and machine learning algorithms to analyze historical campaign data and customer interactions. By identifying patterns and predicting which messaging resonates best with specific audiences, Opal generates tailored content suggestions and optimization tips.

This continuous learning approach allows Opal to adapt to changing trends and provide relevant, data driven insights, reducing guesswork and accelerating marketing workflows.

Core Capabilities and AI Architecture

Campaign Ideation

Opal assists in generating campaign ideas based on existing content trends and data. Features like objective pre population and topic suggestions allow content creators to brainstorm and initiate campaigns more quickly, supported by AI insights.

AI-powered campaign generation with Optimizely Opal

AI-powered campaign generation with Opal

Content Generation

Opal uses AI to generate a wide range of SEO optimized content such as headlines, product descriptions, and marketing texts for digital channels including web, email, and social media. It adapts outputs to suit different formats and platforms.

The assistant also analyzes user and performance data to suggest relevant topics, headlines, and keywords. This keeps content teams aligned with target audience interests, ensuring messaging remains relevant and effective.

Use cases include:

  1. E-Commerce: In e-commerce, OPAL can automatically generate SEO optimized product descriptions based on features such as color, size, or material, accelerating content creation for large catalogs.

  2. Personalized Email Marketing: AI can personalize email campaigns based on user behavior. For example, retail brands can use OPAL to recommend products based on a user’s previous purchases or browsing history.

  3. Content Personalization on Websites: AI adapts on page content in real time. If a user frequently views specific product types, OPAL can display more relevant articles, offers, or recommendations on the homepage.

  4. Automatic content generation: OPAL uses AI to create content such as headlines, product descriptions, and texts for various digital channels (web, email, social media). The content is SEO optimized and adapted to different formats.

Help Your Customers Accelerate Marketing Excellence With Optimizely Opal

Content Optimization

  1. Optimizing blogs and articles: AI writing assistants can optimize articles for SEO by analyzing existing content and suggesting better titles, keywords, or structure for higher search visibility.

  2. Dynamic Ad Personalization: OPAL can dynamically adjust displayed ads based on user interests and behavior, showing relevant offers or discounts in real time.

  3. A/B Testing: OPAL supports running content A/B tests, like testing different headlines, CTAs, or images, and automatically optimizes based on performance data.

Personalized email marketing using AI assistant

Personalization

Opal dynamically adapts content in real time using behavioral signals, demographics, and historical user data. This includes adjusting product displays, banners, and articles to better resonate with individual visitors.

It also supports advanced user segmentation based on preferences, behavior, and past engagement, enabling tailored content experiences for distinct audience groups.

Examples include:

  • Dynamic content personalization: OPAL uses AI to adapt content in real time based on user behavior and preferences. Using data such as browsing history, demographics, and previous engagement, it can change product displays, articles, or banners.

  • User segmentation: OPAL enables user segmentation based on behavior, interests, and other data points, allowing different user groups to receive customized content experiences.

AI-Driven Optimization

Opal provides powerful tools for enhancing content performance:

  • Predictive Analytics: By analyzing historical data and behavior trends, OPAL can predict future user behavior. This allows marketers to better plan content strategies and optimize performance.

  • A/B Testing: OPAL supports automated A/B testing, analyzing results and optimizing content in real time. Based on performance, it can recommend the best-performing variant of a page or message.

In advertising, Opal dynamically adjusts visual and text elements in real time to maximize engagement and conversions based on live performance data.

Image Management

Opal improves visual content handling with:

  • AI Tagging: Automatically categorizes images by analyzing visual elements.

  • Smart Focal Points: Centers key parts of an image (like faces) based on visual weight and channel dimensions, ensuring optimal rendering across responsive designs.

  • Great for responsive image handling across channels.

DAM Integration

With Opal’s integration into Digital Asset Management (DAM), users benefit from smart tagging, AI-assisted batch uploads, and faster asset search and retrieval, all of which streamline content organization and reuse.

CMS Integration

OPAL seamlessly integrates with Optimizely CMS, enhancing content creation and delivery with AI:

AI-Driven Content Personalization and Generation:

  • OPAL can generate and recommend content directly within the CMS, including headlines, descriptions, images, and more, tailored to user data and behavioral signals.

Instruction-Driven Personalization and Governance:

  • Within CMS and across the platform, Opal supports “Instructions”, plain-text rules that guide AI behavior. For example, marketers can define brand tone, compliance boundaries, or channel-specific preferences, ensuring every output aligns with strategic goals. These rules are easy to manage without requiring developer support.

A/B Testing and Optimization Inside CMS:

  • CMS users can perform A/B testing directly within the interface, with OPAL analyzing results and recommending the best-performing content variation (e.g., CTA buttons, titles, images).

Automated Workflows:

  • When combined with CMS, OPAL enables end-to-end automation of content creation, optimization, and publishing, significantly reducing manual workload.

AI-Powered Personalization:

  • Optimizely CMS supports real-time AI driven personalization across channels (web, mobile, email, ads). Through OPAL, content dynamically adapts based on each user’s profile and interaction history.

Nothing lost in translation

  • Translate content within the CMS utilizing AI and machine translation.

  • Translation without rebuilding content structures

Note: If you’re considering OPAL for your Optimizely CMS workflow, please note that the most seamless and complete integration is currently available for SaaS CMS users working with the Content Marketing Platform (CMP). Direct integration without CMP or on non-SaaS versions of the CMS may offer fewer features at this stage. OPAL’s integration is rapidly advancing, and direct OPAL-to-CMS capabilities for other environments are still in progress. Stay tuned for further updates as the platform evolves.

Agentic AI & Workflow Automation

Opal is more than a chatbot, it’s a fully agentic platform. Users can create or deploy prebuilt autonomous agents that perform advanced tasks on their behalf. These agents can be sequenced into workflows, running in parallel or triggered by chat, schedules, or events. This enables dynamic campaign planning, automated experimentation, and adaptive content deployment with minimal manual intervention.

Opal in the Content Lifecycle

Opal supports the entire content lifecycle, ensuring consistent AI enablement at each step:

Opal Lifecycle

AI Architecture & Tech Stack

In addition to its partnership with Google Gemini, Opal operates on a deeply integrated AI layer within Optimizely One. This includes unified access to campaign history, customer data (like brand assets), analytics, and contextual signals, allowing for rich enrichment and minimal hallucinations in AI outputs. Tools and agents access a shared library of capabilities such as image analysis, document summarization, web browsing, and data transformation.

Upcoming Features (Roadmap Highlights)

Feature Status Description
Campaign Ideation UI Coming Soon UI for AI-generated campaign suggestions in CMP
Suggested Segments Beta Intelligent segment suggestions based on past campaign data
AI Agents & Task Creation Private Beta Auto-create tasks, assign users, and manage campaigns dynamically
Resource Manager ETA: Late 2025 AI-assisted workload and resource allocation across campaigns
Auto-Localization Planned AI detection of translatable content and automatic localization workflows
Compliance Guardrails Planned Automated compliance checks for content based on predefined rules
Agent Workflows Coming May 2025
Compose multi-step workflows with multiple agents working in parallel or sequence

Integration with OptimizelyOne

Opal works seamlessly across OptimizelyOne, including:

  • CMP (Content Marketing Platform)

  • DAM (Digital Asset Management)

  • Experimentation & A/B Testing

  • Analytics (NetSpring integration for insights)

It enables brand specific tone adjustments, unified content generation across formats, and consistent AI driven support through the marketing stack.

Strategic Value

Opal provides meaningful value by:

  • Accelerates time-to-market for campaigns and content.

  • Improves accuracy and relevancy through AI driven suggestions.

  • Reduces manual workload through automation of repetitive tasks.

  • Supports scalability with smart segmentation and workflow enhancements.

Tips for Getting the Most Out of Opal

  • Provide clear input details like target audience and campaign goals to get more relevant AI suggestions.

  • Treat AI generated content as a starting point and refine it to maintain your brand’s unique voice.

  • Combine Opal’s speed and data insights with human creativity for best results.

  • Use Optimizely’s built in testing features to A/B test and optimize your campaigns effectively.

Conclusion

Optimizely OPAL offers robust capabilities for AI based content generation, personalization, and optimization. Through its integration with Optimizely CMS, it allows marketers and content teams to generate, test, and publish personalized content at scale with minimal manual effort. With its predictive analytics and automated workflows, OPAL helps organizations deliver highly relevant, engaging, and conversion-optimized content across all digital channels.

Meet Optimizely Opal

Despite its powerful AI driven capabilities, Opal is designed to assist, not replace, human creativity and judgment. Users should review AI generated content to ensure it matches brand tone and compliance standards.

]]> https://blogs.perficient.com/2025/05/22/opal-optimizely-ai-marketing-assistant/feed/ 2 381808 Common Errors When Using GraphQL with Optimizely https://blogs.perficient.com/2025/05/05/common-errors-when-using-graphql-with-optimizely/ https://blogs.perficient.com/2025/05/05/common-errors-when-using-graphql-with-optimizely/#respond Mon, 05 May 2025 17:00:55 +0000 https://blogs.perficient.com/?p=380453

What is GraphQL?

GraphQL is a powerful query language for APIs that allows clients to request only the data they need. Optimizely leverages GraphQL to serve content to your platform agnostic presentation layer. This approach to headless architecture with Optimizely CMS is gaining traction in the space and developers often encounter new challenges when transitioning from the more common MVC approach.

In this blog post, we will explore some common errors you’ll encounter and how to troubleshoot them effectively.

 

Common Errors

1. Schema Mismatches

Description

Some of the most frequent issues arise from mismatches between the GraphQL schema and the content models in Optimizely. This can occur from mistyping fields in your queries, not synchronizing content in the CMS, or using the wrong authentication key.

Example Error

{
"errors": [
    {
      "message": "Field \"Author\" is not defined by type \"BlogPage\".",
      "locations": [
        {
          "line": 2,
          "column": 28
        }
      ]
    }
  ]
}

Solution

  • Double check your query for any mismatches between field and type names
    • Case-sensitivity is enforced on Types/Properties
  • Validate that the API Key in your GraphQL Query matches the API Key in the CMS environment you’ve updated
  • Ensure that your GraphQL schema is up-to-date with the latest data model changes in Optimizely.
    • If you are running the CMS with the same Graph API Keys, check the GraphQL Explorer tab and validate that your type shows in the listing
  • Run the ‘Optimizely Graph content synchronization job’ from the CMS Scheduled Jobs page.
    • After you see the Job Status change from ‘Starting execution of ContentTypeIndexingJob’ to ‘Starting execution of ContentIndexingJob’ you can stop the job and re-run your query.
  • Reset the Account
    • If all else fails you may want to try to reset your GraphQL account to clear the indices. (/EPiServer/ContentGraph/GraphQLAdmin)
    • If you are sharing the key with other developers the schema can become mismatched when making local changes and synchronizing your changes to the same index.

2. Maximum Depth

Description

When querying nested content, you may see an empty Content object in the response rather than your typed content.

Example Error

In this scenario, we are trying to query an accordion set block which has multiple levels of nested content areas.

Query

query MyQuery {
  Accordion {
    items {
      PanelArea{
        ContentLink {
          Expanded {
            ... on AccordionPanel{
              PanelContent{
                ContentLink {
                  Expanded {
                    ... on CardGrid{
                      CardArea {
                        ContentLink {
                          Expanded {
                            ... on Card{
                              CtaArea{                                
                                ContentLink{
                                  Expanded{
                                    __typename
                                    ...on Button {
                                      __typename
                                    }

Response

{
  "data": {
    "Accordion": {
      "items": [
        {
          "PanelArea": [
            {
              "ContentLink": {
                "Expanded": {
                  "PanelContent": [
                    {
                      "ContentLink": {
                        "Expanded": {
                          "CardGrid": [
                            {
                              "ContentLink": {
                                "Expanded": {
                                  "CtaArea": [
                                    {
                                      "ContentLink": {
                                        "Expanded": {
                                          "__typename": "Content"
                                        }
       ...
}

Solution

  • Configure GraphQL to use higher maximum depth in appsettings
    • The default level of nesting content is 3, but that can be modified in Startup.CS
      services.AddContentGraph(options => { options.ExpandLevel.Default = 5 options.ExpandLevel.ContentArea = 5; });
    • Note that increasing this will increase the document size and make the synchronization job much slower depending on the amount of content and level of nesting in your site.
  • Break-up requests into multiple queries.
    • Instead of expanding the inline fragment (… on Block) instead get the GuidValue of the ContentModelReference and use subsequent queries to get deeply nested content.
    • Consider making this extra request asynchronously on the client-side to minimize performance impact.

3. Authentication Errors

Description

There are a few different scenarios where you can get a 401 Authentication Error response on your GraphQL query.

{
  "code": "AUTHENTICATION_ERROR",
  "status": 401,
  "details": {
    "correlationId": "1234657890"
  }
}

Solution

  • Check your authentication tokens and ensure they are valid.
  • If you are querying draft content you need to configure and enable preview tokens Documentation

4. Unsynchronized Content

Description

When making updates to content in the CMS, you will occasionally run into issues where you don’t see the updated content on the page or in the graph response.

Solution

  • Confirm that Content has been synchronized
    • In the CMS you can determine whether or not Content has been synchronized by the checkmark icon in the Publish Options ‘Synchronize with Optimizely Graph’ button
      Optimizely Graph Publish Options
    • If the ‘Synchronize with Optimizely Graph’ button is not triggering the content to be synced check to see if either of the Optimizley Graph Synchronization Jobs are in progress.  When they are running, manually syncing content will be delayed until job completion.
  • Validate that your CMS Graph API Key matches the API Key in your front-end/graph query
]]> https://blogs.perficient.com/2025/05/05/common-errors-when-using-graphql-with-optimizely/feed/ 0 380453 Optimizing Experiences with Optimizely: Custom Audience Criteria for Mobile Visitors https://blogs.perficient.com/2025/03/05/optimizing-experiences-with-optimizely-custom-audience-criteria-for-mobile-visitors/ https://blogs.perficient.com/2025/03/05/optimizing-experiences-with-optimizely-custom-audience-criteria-for-mobile-visitors/#comments Wed, 05 Mar 2025 22:06:56 +0000 https://blogs.perficient.com/?p=378170

In today’s mobile-first world, delivering personalized experiences to visitors using mobile devices is crucial for maximizing engagement and conversions. Optimizely’s powerful experimentation and personalization platform allows you to define custom audience criteria to target mobile users effectively.

By leveraging Optimizely’s audience segmentation, you can create tailored experiences based on factors such as device type, operating system, screen size, and user behavior. Whether you want to optimize mobile UX, test different layouts, or personalize content for Android vs. iOS users, understanding how to define mobile-specific audience criteria can help you drive better results.

In this blog, we’ll explore how to set up simple custom audience criteria for mobile visitors in Optimizely, the key benefits of mobile targeting, and the best practices to enhance user experiences across devices. Let’s dive in!

This solution is based on Example – Create audience criteria, which you can find in the Optimizely documentation.

Create the settings and criterion classes

First, we need to create two classes in our solution:

Class VisitorDeviceTypeCriterionSettings needs to inherit CriterionModelBase class, and we need only one property (settings) to determine if the visitor is using a desktop or a mobile device.

public bool IsMobile { get; set; }

The abstract CriterionModelBase class requires you to implement the Copy() method. Because you are not using complex reference types, you can implement it by returning a shallow copy as shown (see Create custom audience criteria):

public override ICriterionModel Copy()
{
    return base.ShallowCopy();
}

The entire class will look something like this:

using EPiServer.Data.Dynamic;
using EPiServer.Personalization.VisitorGroups;

namespace AlloyTest.Personalization.Criteria
{
    [EPiServerDataStore(AutomaticallyRemapStore = true)]
    public class VisitorDeviceTypeCriterionSettings : CriterionModelBase
    {
        public bool IsMobile { get; set; }

        public override ICriterionModel Copy()
        {
            // if this class has reference types that require deep copying, then
            // that implementation belongs here. Otherwise, you can just rely on
            // shallow copy from the base class
            return base.ShallowCopy();
        }
    }
}

Now, we need to implement the criterion class VisitorDeviceTypeCriterion and inherit the abstract CriterionBase class with the settings class as the type parameter:

public class VisitorDeviceTypeCriterion : CriterionBase<VisitorDeviceTypeCriterionSettings>

Add a VisitorGroupCriterion attribute to set the category, name, and description of the criterion (for more available VisitorGroupCriterion properties, see Create custom audience criteria:

[VisitorGroupCriterion(
    Category = "MyCustom",
    DisplayName = "Device Type",
    Description = "Criterion that matches type of the user's device"
)]

The abstract CriterionBase class requires you to implement an IsMatch() method that determines whether the current user matches this audience criterion. In this case, we need to determine from which device the visitor is accessing our site. Because Optimizely doesn’t provide this out of the box, we need to figure out that part.

One of the solutions is to use information from the request header, from the User-Agent field and analyze it to determine the OS and device type. We can do that by writing our match method:

public virtual bool MatchBrowserType(string userAgent)
{
    var os =
        new Regex(
            @"(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od|ad)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino",
            RegexOptions.IgnoreCase | RegexOptions.Multiline);
    var device =
        new Regex(
            @"1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-",
            RegexOptions.IgnoreCase | RegexOptions.Multiline);
    var deviceInfo = string.Empty;

    if (os.IsMatch(userAgent))
    {
        deviceInfo = os.Match(userAgent).Groups[0].Value;
    }

    if (device.IsMatch(userAgent.Substring(0, 4)))
    {
        deviceInfo += device.Match(userAgent).Groups[0].Value;
    }

    if (!string.IsNullOrEmpty(deviceInfo))
    {
        return true;
    }

    return false;
}

Now, we can go back and implement the IsMatch() method that is required by CriterionBase abstract class.

public override bool IsMatch(IPrincipal principal, HttpContext httpContext)
{
    return MatchBrowserType(httpContext.Request.Headers["User-Agent"].ToString());
}

 

Test the criterion

In the CMS we need to create a new audience criterion. When you click on the ‘Add Criteria’ button, there will be ‘MyCustom’ criteria group with our criteria:

When you select the ‘Device Type’ criteria, you will see something like this:

We can easily add a label for the checkbox by using Optimizely’s translation functionality. Create a new XML file VisitorGroupCriterion.xml and place it in your translations folder where your translation files are, like this:

Put this into the file that you created:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<languages>
  <language name="English" id="en-us">
    <visitorgroups>
      <criteria>
        <ismobile>
          <key>Is Mobile Device (Use this setting to show content only on Mobile)</key>
        </ismobile>
      </criteria>
    </visitorgroups>
  </language>
</languages>

 

There is one more thing to do. In VisitorDeviceTypeCriterionSettings.cs, decorate the IsMobile property with the translation definition. Add this attribute:

[CriterionPropertyEditor(LabelTranslationKey = "/visitorgroups/criteria/ismobile/key")]

It should look like this:

Now, in the editor view, we have a label for the checkbox.

 

Personalize the content by setting the content for this visitor group.

Desktop view:

 

Mobile view:

You can see that there is content that is only visible if you access the site with a mobile device.

 

And that’s it!

]]> https://blogs.perficient.com/2025/03/05/optimizing-experiences-with-optimizely-custom-audience-criteria-for-mobile-visitors/feed/ 1 378170 How Optimizely Grew from a CMS to a Composable Powerhouse https://blogs.perficient.com/2025/02/17/how-optimizely-grew-from-cms-to-composable-powerhouse/ https://blogs.perficient.com/2025/02/17/how-optimizely-grew-from-cms-to-composable-powerhouse/#respond Mon, 17 Feb 2025 18:58:45 +0000 https://blogs.perficient.com/?p=380736

Before the term Digital Experience Platform (DXP) became a fixture in martech conversations, content management systems were the workhorses of digital strategy. Brands turned to CMS platforms like Episerver (now Optimizely) to manage web content, create publishing workflows, and maintain consistent brand identity online.

But the evolution from CMS to DXP didn’t happen overnight — and Optimizely has been at the heart of that journey.

From CMS to More: Optimizely’s Foundation as a Marketing-Ready Platform

Long before it was officially labeled a DXP, Optimizely’s CMS stood out for its extensibility. It offered robust content modeling, multi-site management, and support for editorial workflows — but where it really gained traction was in its ability to integrate.

Through connectors, add-ons, and APIs, the CMS expanded far beyond traditional publishing. Key integrations included:

  • CRM Platforms: Microsoft Dynamics, Salesforce, and others could be integrated to sync customer data for personalized content delivery.
  • Translation Providers: Tools like Lionbridge, Smartling, and Translations.com were easily added to support global content publishing workflows.
  • Marketing Automation: Platforms like Marketo, HubSpot, and Eloqua could be connected for form tracking, lead capture, and campaign orchestration.
  • Search Providers: Episerver Find (now Optimizely Search & Navigation) was a built-in option, but clients could also use Coveo, Algolia, and Lucidworks.
  • Commerce Engines: Its deep integration with Episerver Commerce (now Optimizely Commerce) made it a favorite among hybrid content-and-commerce teams.

Optimizely’s modular and API-first approach helped clients build tailored digital experiences well before the concept of a “DXP” was formally defined.

Enter the Modern DXP: Composable, Scalable, and Open

Today, Optimizely is more than a CMS — it’s a full-fledged, composable Digital Experience Platform. It combines content, commerce, experimentation, data, and personalization into a unified ecosystem. But what truly sets Optimizely apart in the modern era is its composable architecture.

Rather than forcing brands into a monolithic suite, Optimizely allows them to pick and choose the capabilities they need, and plug in best-of-breed tools for everything else. Whether it’s connecting to a PIM like Salsify, a DAM like Bynder, or a front-end framework hosted on Vercel — the platform is built to support:

  • Composable Integrations: APIs and GraphQL endpoints power seamless data access for headless and hybrid deployments.
  • Open Architecture: Built-in support for third-party search (Coveo, HawkSearch), CDPs, analytics tools, and design systems.
  • Cloud-Native SaaS: As a SaaS-first platform, Optimizely offers automatic updates, built-in scalability, and security out-of-the-box.
  • AI-Driven Insights: Tools like Optimizely Content Recommendations, ODP (Optimizely Data Platform), and Experimentation bring data into the experience layer.

Why It Matters

Organizations today need agility. Customer expectations shift fast, and the technology that powers those experiences must be flexible. Optimizely’s journey from a CMS with strong marketing integrations to a composable DXP allows teams to evolve their digital strategy at their own pace — without starting from scratch.

By supporting both integrated suites and headless-first deployments, Optimizely gives marketers, developers, and digital leaders a platform that meets them where they are — and grows with them into the future.

]]> https://blogs.perficient.com/2025/02/17/how-optimizely-grew-from-cms-to-composable-powerhouse/feed/ 0 380736 Optimizely SaaS CMS Advancements https://blogs.perficient.com/2025/02/06/optimizely-saas-cms-advancements/ https://blogs.perficient.com/2025/02/06/optimizely-saas-cms-advancements/#respond Thu, 06 Feb 2025 18:55:13 +0000 https://blogs.perficient.com/?p=376978

Delivering exceptional digital experiences requires a powerful, flexible, and scalable content management system. Optimizely’s SaaS CMS continues to evolve with new features and innovations designed to drive efficiency, enhance flexibility, and unlock greater value. Perficient, a trusted leader in digital transformation, has deep expertise in Optimizely solutions, helping businesses implement and optimize their CMS strategies for maximum impact. Here’s a look at the latest advancements that can enhance content management and customer experiences.

Why SaaS CMS Matters

SaaS CMS was developed to provide businesses with a seamless, scalable, and cost-efficient content management solution. Key benefits include:

  • Automatic Updates: Stay up to date with the latest features—no manual effort required.
  • Scalability: Effortlessly handle traffic spikes and evolving content needs.
  • Flexibility: Headless configurations and multi-channel delivery for diverse requirements.
  • Superior User Experience: Streamlined workflows, continuous releases, and faster time to value.

By combining these strengths, SaaS CMS enables businesses to adapt to ever-changing digital demands and deliver engaging, personalized content efficiently.

New Features and Enhancements

1. Visual Builder Enhancements

  • Section-Enabled Blocks: Editors can leverage preconfigured design elements, improving productivity and consistency. Reusable templates ensure faster page builds without requiring technical expertise.
  • Interactive Previews: Real-time previews at the element level allow teams to visualize changes instantly, reducing errors and enhancing collaboration.
  • Styling Control: Developers can define style options, ensuring brand consistency while giving editors a guided but flexible approach to design.

2. Robust Scalability

  • SaaS CMS now includes hyperscaler capabilities to handle increased traffic automatically. Hosting flexibility and reliability are enhanced through integrations with Vercel and Netlify, enabling seamless scaling.

3. Enhanced Content Modeling and Multi-Step Workflows

  • The new Content Modeling UI simplifies content structuring, making it easier to create and manage content types.
  • Customizable multi-step workflows streamline approval processes and improve content governance.

4. Expanded Language Support

  • Enhanced semantic search capabilities support additional languages, broadening global reach.
  • AI-driven search refines content discovery by understanding user intent and delivering more accurate results.

5. HIPAA-Ready Compliance

  • For organizations in healthcare and other regulated industries, SaaS CMS now supports HIPAA readiness, ensuring compatibility with compliance requirements.

What’s on the Roadmap?

Graph Portal

  • A new Graph Portal will enable teams to build and manage queries, set up webhooks, and troubleshoot with ease.

AI-Powered Auto-Translations

  • Automated translations will simplify multilingual content management, allowing businesses to expand their global presence efficiently.

Integrated Digital Asset Management (DAM)

  • A seamless DAM integration will eliminate the need to switch between systems, streamlining content workflows.

Embedded Experimentation and Personalization

  • A/B testing and feature experimentation will be embedded directly into the CMS UI, enabling businesses to deliver personalized digital experiences with precision.

How SaaS CMS Drives Business Value

  • Faster Time to Market: Automatic updates, reusable components, and intuitive tools accelerate project delivery.
  • Enhanced User Experiences: Organizations can deliver personalized, scalable, and engaging content across channels effortlessly.
  • Cost Efficiency: Reduced operational overhead allows businesses to allocate resources more effectively.

Perficient’s Optimizely practice helps organizations implement and maximize the benefits of SaaS CMS, ensuring they stay ahead of evolving digital needs. By leveraging these new advancements, businesses can optimize their content strategy, enhance user engagement, and drive measurable results.

]]> https://blogs.perficient.com/2025/02/06/optimizely-saas-cms-advancements/feed/ 0 376978