Designing Scalable Catalog Structures in Optimizely Commerce

In any eCommerce solution, the catalog is the backbone of the digital experience. A well-designed catalog structure in Optimizely Commerce ensures fast performance, easy management, and a smooth customer journey — while a poorly designed one can lead to slow searches, frustrated merchandisers, and scalability challenges as the business grows.

In this article, we’ll explore how to design scalable catalog structures in Optimizely Commerce, the key considerations, and best practices learned from projects.

Why Catalog Design Matters

Optimizely Commerce can handle thousands of SKUs, but the way you structure your catalog directly impacts:

• Performance → Faster search, indexing, and page load times.

• User Experience → Easier navigation, better filtering, fewer clicks.

• SEO → Clean URLs, optimized category hierarchies, breadcrumb trails.

• Maintainability → Simpler workflows for merchandisers and admins.

• Scalability → Ability to expand into new markets, product lines, or currencies without restructuring.

Example structure:

Catalog: Fashion Store  
 └── Category: Men’s Clothing  
      └── Product: Oxford Shirt  
           ├── Variant: Blue, Size M  
           ├── Variant: Blue, Size L  
           └── Variant: White, Size M 

Catalog Design Considerations for Scalability

When structuring your catalog, keep in mind:

1. Performance – Large categories with thousands of items can slow down queries.

2. Navigation & UX – Customers should reach products in 3–4 clicks max.

3. SEO – URLs and breadcrumbs should reflect clean hierarchies.

4. Admin Usability – Merchandisers need intuitive structures.

5. Localization – Plan for multi-language, multi-market, multi-currency setups.

Common Catalog Design Patterns

1. Single vs Multi-Catalog

=> Diagram: Single vs Multi-Catalog

Single Catalog (Recommended for most cases): 

Catalog Root
 ├── Men’s Clothing
 ├── Women’s Clothing
 ├── Footwear
 └── Accessories

Multi-Catalog (When business models differ):

B2C Catalog
 ├── Men’s Clothing
 ├── Women’s Clothing

B2B Catalog
 ├── Bulk Apparel
 ├── Corporate Footwear

=> Start with a single catalog unless you have strong business reasons (different assortments, B2B vs B2C).

2. Flat vs Deep Category Hierarchies

=> Diagram: Catalog Hierarchies

Flat Catalog (Simpler, but wide categories):

Fashion Store
 ├── Shirts (500 SKUs)
 ├── Pants (400 SKUs)
 ├── Shoes (6,000 SKUs)
 └── Accessories (3,000 SKUs)

Deep Catalog (Organized):

Fashion Store
 └── Men’s Clothing
      └── Tops
           └── Shirts (1,000 SKUs)
      └── Bottoms
           └── Pants (800 SKUs)
 └── Footwear
      ├── Casual Shoes (2,000 SKUs)
      ├── Formal Shoes (1,500 SKUs)
      └── Sports Shoes (2,500 SKUs)

 Best Practice: Keep category depth 2-3 levels max and balance the size of each category.

3. Product vs Variant Modeling

=> Diagram: Product → Variants

Product: Shirt
 ├── Variant: Blue, Size M
 ├── Variant: Blue, Size L
 ├── Variant: White, Size M
 └── Variant: White, Size L

Code Example: Defining Product & Variants

[CatalogContentType(
    DisplayName = "Shirt Product",
    GUID = "630CB424-945B-48F3-9116-C8E15C8B1E0D",
    MetaClassName = "ShirtProduct")]
public class ShirtProduct : ProductContent
{
    [Display(Name = "Brand")]
    public virtual string Brand { get; set; }

    [Display(Name = "Material")]
    public virtual string Material { get; set; }
}

[CatalogContentType(
    DisplayName = "Shirt Variant",
    GUID = "2B586ABE-1646-4140-8E3E-7FEE3398E440",
    MetaClassName = "ShirtVariant")]
public class ShirtVariant : VariationContent
{
    [Display(Name = "Color")]
    public virtual string Color { get; set; }

    [Display(Name = "Size")]
    public virtual string Size { get; set; }
}

Use variants for attributes like size and color; use separate products when items differ significantly or need unique SEO pages.

4. Associations for Better Cross-Sell

Use associations to improve average order value :

• Accessories → Phone → Case, Charger.

• Up-sell → Laptop → Higher model with more RAM.

• Replacement → Printer → Ink cartridge.

This avoids catalog duplication while enabling personalization.

Performance Optimization Techniques

Even the best catalog design needs performance tuning:

1. Search (Optimizely Find)

• Use synonyms (t-shirt = tee).

• Boost by category or sales.

• Avoid unfiltered queries on huge categories.

Code Example: Boosting Search Results

var results = _searchClient
    .Search<ShirtVariant>()
    .For("blue shirt")
    .InFields(x => x.Name, x => x.Color, x => x.Size)
    .Filter(x => x.Color.Match("Blue"))
    .OrderByDescending(x => x.MarketPopularity) // Boost popular products
    .Take(20)
    .GetResult();

  2. Caching

• Use output caching for product/category pages.

• Implement distributed caching (e.g., Redis) in high-traffic environments.

  3. Lazy Loading

• Load related products/variants only when needed.

  4. Batch Operations

• Use bulk APIs for imports and updates instead of looping item-by-item.

Best Practices

• Keep categories logical & balanced (avoid dumping 10,000+ items into a single category).

• Don’t duplicate products — use associations.

• Plan for future expansion (new markets, currencies, or product lines).

• Regularly test indexing performance for large catalogs in Find.

Conclusion

Designing a scalable catalog in Optimizely Commerce is not just about organizing products — it’s about creating a foundation for performance, SEO, and long-term growth.

Thanks :)