All articles
E-commerceNovember 4, 2026 6 min read

Shopify Metaobjects for Product Configurators: A Build Pattern That Scales

Metaobjects quietly replaced half the apps we used to install. Here's how we model a product configurator on Shopify without a custom backend — and where the pattern starts to break.

Every few months a client asks us to build a product configurator on Shopify — custom desks, engraved jewellery, bundled skincare kits, bike builds. The default answer used to be "install an app and pray." Since metaobjects matured, that answer is wrong. Here's the pattern we now reach for, and the places it still falls over.

Why the old approaches hurt

Before metaobjects, you had three bad options.

The first was variants. Shopify's 100-variant limit (now 2,000 on newer plans, but still finite) collapses the moment a configurator has four or five axes. A desk with 6 widths × 4 depths × 8 finishes × 3 leg styles is 576 variants before you add cable management.

The second was options apps. These typically store configuration as line item properties and inject JavaScript into the product page. They work, but they fight the theme, slow the page, and almost always break checkout extensibility or Shop Pay in some edge case. We've debugged enough of these to be allergic.

The third was going headless with a custom product model in a separate CMS. Fine for large catalogues, overkill for a brand with 40 SKUs and one configurable hero product.

Metaobjects give you a fourth option: model the configuration data natively in Shopify, render it with native theme sections or the Storefront API, and keep the checkout untouched.

The data model

Think of the configurator as a graph. The product is the root. Each configurable axis is a metaobject definition. Each option on that axis is a metaobject entry.

For a desk builder, we'd define:

  • desk_size — fields: label, width_cm, depth_cm, price_delta, sku_fragment
  • desk_finish — fields: label, swatch_image, price_delta, sku_fragment, lead_time_days
  • desk_legs — fields: label, preview_image, price_delta, sku_fragment, compatible_sizes (list reference to desk_size)

The product itself gets a metafield of type list.metaobject_reference for each axis, pointing to the valid entries for that product. This is the key move: options are shared, assignments are per-product. A new finish becomes one metaobject entry, instantly available to any product that references it.

Handling compatibility rules

Real configurators have rules. Some leg styles don't fit the smallest desktop. Certain finishes aren't available in the deepest size because the sheet stock doesn't come that wide.

We model compatibility as reference fields on the option itself — compatible_sizes on the leg metaobject, for example. The front end reads those references and disables incompatible choices. This keeps rules co-located with the data they constrain, rather than hiding them in a separate rules engine nobody maintains.

For anything more complex than pairwise compatibility (say, "if finish is walnut AND size is XL, add 10 days lead time"), we add a configurator_rules metaobject with condition and effect JSON fields. We've only needed this twice in two years of shipping configurators.

Rendering on the storefront

You have two paths. Pick based on how much interactivity the configurator needs.

Path A: Liquid + Alpine.js

For most configurators, this is enough. Render the metaobject data into a JSON script tag, then let a small Alpine component drive the UI.

{% assign sizes = product.metafields.configurator.sizes.value %}
{% assign finishes = product.metafields.configurator.finishes.value %}

<script type="application/json" id="config-data">
{
  "sizes": [
    {% for s in sizes %}
      {
        "id": {{ s.id | json }},
        "label": {{ s.label | json }},
        "priceDelta": {{ s.price_delta.value | default: 0 }},
        "sku": {{ s.sku_fragment | json }}
      }{% unless forloop.last %},{% endunless %}
    {% endfor %}
  ],
  "finishes": [ /* ... */ ]
}
</script>

<div x-data="configurator()" x-init="init()">
  <template x-for="size in sizes" :key="size.id">
    <button @click="selectedSize = size"
            :class="{ active: selectedSize?.id === size.id }"
            x-text="size.label"></button>
  </template>

  <div class="price" x-text="formatPrice(totalPrice)"></div>

  <button @click="addToCart()">Add to cart</button>
</div>

On add-to-cart, you submit the base product variant with line item properties capturing the selections:

async function addToCart() {
  const properties = {
    'Size': this.selectedSize.label,
    'Finish': this.selectedFinish.label,
    'Legs': this.selectedLegs.label,
    '_config_sku': [
      this.baseSku,
      this.selectedSize.sku,
      this.selectedFinish.sku,
      this.selectedLegs.sku
    ].join('-')
  };

  await fetch('/cart/add.js', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      id: this.baseVariantId,
      quantity: 1,
      properties
    })
  });
}

Properties prefixed with underscore are hidden from the customer but visible in the admin and on exported orders. That's where we stash the composite SKU the warehouse actually needs.

Path B: Storefront API with a React island

When the configurator has live 3D previews, real-time pricing queries against an ERP, or needs to persist a saved configuration across sessions, we go headless for that one component. The rest of the theme stays Liquid.

Query metaobjects via the Storefront API:

query ConfiguratorData($handle: String!) {
  product(handle: $handle) {
    id
    variants(first: 1) { nodes { id price { amount } } }
    sizes: metafield(namespace: "configurator", key: "sizes") {
      references(first: 50) {
        nodes {
          ... on Metaobject {
            id
            fields { key value reference { ... on MediaImage { image { url } } } }
          }
        }
      }
    }
  }
}

The React component mounts into a <div id="configurator-root"> placeholder in the Liquid template. We get framework ergonomics where we need them without rewriting the whole storefront.

The pricing problem

This is where every configurator pattern eventually meets reality: Shopify charges whatever the variant price is, not whatever your JavaScript calculated.

You have three honest ways to handle configuration pricing:

  1. Price tiers as variants. Create 5 – 10 variants representing price bands (e.g. Base, +£50, +£100, +£250). Your JS calculates the total delta and selects the matching variant to add. Clean, works with Shop Pay, keeps reporting sane. This is our default.

  2. A single "custom" variant plus a draft order. The add-to-cart posts configuration to an app proxy; a backend creates a draft order with the exact price and sends an invoice. Fine for high-value, low-volume (kitchen islands, bespoke furniture). Terrible UX for a £90 impulse buy because you lose Shop Pay and express checkouts.

  3. Shopify Functions for cart transforms. Use a cart transform function to add a price adjustment line based on the line item properties. Powerful but requires an app, and the mental model is harder to debug. We reach for this when the variant-tier approach would need more than 20 tiers.

Pick one and stick with it per store. Mixing approaches across products is how you end up with reconciliation nightmares at month end.

Where the pattern breaks

Be honest with yourself before committing.

  • Inventory per combination. If every configuration consumes distinct stock, metaobjects won't save you — you need variants or a real PIM/ERP integration. Metaobjects assume the base product has enough raw inventory or is made to order.
  • Catalog search and filtering. Shoppers can't filter the collection page by "walnut finish" if walnut is a metaobject reference rather than a variant option. You can rebuild filtering with a search app that indexes metafields (Searchanise, Algolia), but that's extra cost and complexity.
  • Returns and exchanges. Warehouse and CS teams need to read the composite SKU from the order. Train them, and make sure the _config_sku property surfaces in your OMS.
  • Translations. Metaobject field values can be translated via the Translate & Adapt app or the Translations API, but list reference ordering doesn't translate — the sort order is global. Minor gotcha, worth knowing.

What we'd do

If you're staring at a configurator brief next week, start here: map the configuration to 2 – 4 metaobject definitions, wire them to the product via list reference metafields, and prototype the UI with Liquid plus Alpine before you reach for React. Use variant price tiers until a client use case proves you need cart transforms. Keep the composite SKU in a hidden line item property so the warehouse never guesses.

The whole point of this pattern is that you get 80% of a bespoke configurator without leaving Shopify's native rails — and you keep Shop Pay, checkout extensibility, and the admin workflows your client's team already knows. When that stops being true, you'll feel it, and that's the signal to talk about headless commerce properly rather than bolting more apps onto a theme.

#Shopify#E-commerce#Metaobjects#CRO#Storefront API

Want a team like ours?

72Technologies builds production software for the kind of teams who actually read this blog.

Start a project