Designing Search & Discovery Filters for Large Stores

Store Design
,
1

As highlighted in an earlier question, my Shopify store has a large product selection (90,000 items). To correct the terminology used in that question, we are dividing the store into nine “header/dummy” collections, each with upwards of ten smart collections (utilizing product tags to filter) that will sort them into up to 100-200 items spanning upwards of ten pages.

The idea was then to utilize the built-in Search & Discovery app’s filter feature to enable customers to reduce the remaining items to just a page if the item they are looking for isn’t on the first page of results.

The problems I’m running into now are:

  1. God-Filter[s]: We are reusing single line text Product metafield filters like “Size”, “Version” or “Material”. The problem comes when multiple product lines have different size types (i.e. height, length x width, capacity). Any time a customer searches for a more generic term, every single relevant filter value will appear rendering them in-effect useless. The best solution I can think to this is using specific filters like “[Product Line (Smart Collection) Name] Size”. However, this runs into the second problem . . .
  2. Limited Filter Number (25 maximum): creating single-use principle adherent filters resolves the God-Filter problem highlighted above, but with over 90 smart collections that could all have their own specific filters, it makes me think there’s a more elegant solution to this problem.

Please recommend me the best solution using the Search & Discovery or other built-in Shopify apps. If there are best practices or principles for this design problem, let me know.

2

The best practice for Shopify’s Search & Discovery app—specifically for large, diverse catalogs—is to organize your filters by Data Type, not by Product Line.

Here is the strategy to solve the “God-Filter” problem while staying within the 25-filter limit.

The Core Principle: Context-Aware Faceting

Shopify’s Search & Discovery app follows a “Sparse Data” rule: If none of the products on the current page have data for a specific filter, that filter is automatically hidden.

  • Scenario: You define a “Capacity (Liters)” filter and a “Clothing Size” filter.

  • Result: When a customer views your “T-Shirts” collection, the “Capacity” filter disappears (because shirts don’t have capacity data). When they view “Storage Bins,” the “Clothing Size” filter disappears.

You do not need to create manual “T-Shirt Size” or “Table Size” filters. You simply need to separate your data by its syntax (how the data looks).

The Solution: The “Data-Type” Taxonomy

Instead of creating 90 filters for 90 collections, or 1 giant “God Filter,” you should create roughly 10–15 Universal Metafields based on the nature of the measurement.

This allows you to cover all 90,000 items without hitting the limit. Here is a recommended structure:

1. Split “Size” by Syntax (3-4 Filters)

The “God Filter” problem usually comes from mixing dimensions (10x10) with standard sizes (XL) or volume (50L). Split them into distinct Metafield Definitions:

  • custom.apparel_size: For S, M, L, XL, or numeric clothing sizes.

    • Label: “Size”

  • custom.dimensions: For Length x Width x Height strings (e.g., “10x10x5”).

    • Label: “Dimensions”

  • custom.capacity_volume: For Liters, Gallons, Ounces.

    • Label: “Capacity”

  • custom.shoe_size: (Optional) If you sell shoes, keep this distinct from apparel to avoid mixing “Size 10” (shoe) with “Size 10” (pants).

2. Consolidate “Attribute” Filters (3-5 Filters)

Some attributes are safe to mix because they share values across product lines.

  • custom.material: “Cotton” (Shirts) and “Wood” (Tables) can happily coexist in one filter. In a search result, seeing both is helpful context.

  • custom.color: Always keep this global.

  • custom.compatibility: Use this for “Version,” “Fits With,” or “Model Year.”

3. Use Boolean (Checkboxes) for Features (5-10 Filters)

Instead of a dropdown text list, use True/False Metafields for key features.

  • custom.is_waterproof

  • custom.is_eco_friendly

  • custom.made_in_usa

Why This Fixes Your Search Experience

You mentioned the issue where a generic search (e.g., “Blue”) brings up irrelevant filters. With the Data-Type strategy, the search experience becomes intuitive:

  • User searches: “Blue”

  • Results: Blue T-Shirts and Blue Water Bottles.

  • Sidebar shows:

    • Size (S, M, L) → Clicking this narrows it to Shirts.

    • Capacity (1L, 2L) → Clicking this narrows it to Bottles.

The filters act as a secondary category selector. The user effectively “chooses their path” by selecting the filter relevant to the item they want.

Implementation Plan

Since you admitted your data is “dirty” and inconsistent, you cannot implement this purely in the front end. You need to map the data first.

  1. Define the 12-15 Golden Metafields: Go to Settings > Custom Data > Products and create the definitions above (Apparel Size, Dimensions, Material, etc.).

  2. The “Migration” (Clean Up): You likely have this data currently stored in tags or a generic size field.

    • Tool Recommendation: Use an app like Matrixify (Excel-based).

    • Action: Export your products. Filter by your 9 Dummy Categories. Move the data from your messy legacy columns into the new accurate columns (e.g., Move “XL” to custom.apparel_size, move “10x10” to custom.dimensions).

  3. Configure Search & Discovery: Add your new 12-15 Metafields as filters.

    • Tip: You can rename the display labels. You could name both apparel_size and dimensions as “Size” in the display, but I recommend keeping them distinct (“Size” vs “Dimensions”) to aid the user in Search results.