Showcase concept Studio showcase — a concept build demonstrating our approach.

Aurum

Luxury watch commerce, configured in real time.

Discipline
Web · Headless commerce · WebGL
Stack
Shopify Hydrogen, Remix, Three.js, Oxygen edge
Timeline
14 weeks (concept plan)
Role
Strategy, design engineering, build, performance
01 — The brief

A $40k watch deserves more than a JPEG.

Aurum is a fictional independent watchmaker selling direct, with pieces from AUD $9,800 to $42,000. The concept brief: make configuring a watch feel like sitting at the boutique counter — on a phone, on hotel Wi-Fi.

Collectors want to turn the piece in their hands, see how 18k gold catches light against an emerald dial, and know the exact reference they're buying. The business wants every configuration to be a real, in-stock SKU with landed pricing in four currencies.

Audience
Collectors, 35–60, 70% mobile
Markets
AU · SG · HK · US
Must-haves
Live 3D configurator, multi-currency, sub-second loads
Commerce
Shopify Plus, headless
02 — The challenge

Heavy to look at. Light to load.

Luxury sites usually trade speed for spectacle — 8MB hero videos, six-second loads, configurators that melt mid-range Android phones. We wanted both: real-time 3D with physically based gold, and a storefront that hits LCP under a second.

  1. C/01

    A weight budget for gold

    All 3D assets — case, dials, straps, environment — under 1.2MB total, using Draco geometry and KTX2 textures.

  2. C/02

    Every combination is a SKU

    3 metals × 4 dials × 3 straps = 36 variants, each mapped to live Shopify inventory and price.

  3. C/03

    Edge-rendered, four markets

    Currency and availability resolved at the edge, so pricing never flickers after hydration.

03 — Approach

Four phases, one budget.

Performance targets were written before a single pixel — and enforced in CI from week one.

  1. 01
    wk 1–2

    Discovery & budgets

    Map the 36-variant catalogue, define RUM targets (LCP, INP, frame time) and a device lab of three mid-tier Android phones as the floor.

  2. 02
    wk 3–5

    Material pipeline

    Author PBR metals once, bake environment lighting, and compress every texture to KTX2. Dials swap as material parameters — not new meshes.

  3. 03
    wk 4–10

    Hydrogen storefront

    Streaming SSR on the edge. Configurator state lives in the URL, so every watch is shareable, cacheable and indexable.

  4. 04
    wk 11–14

    Hardening & launch

    Progressive enhancement (a static poster when WebGL is unavailable), real-user monitoring and regression budgets that fail the build.

04 — Interactive

Build your Aurum.

Pick a case, dial and strap. This SVG stand-in runs on the same state model as the production WebGL configurator — one source of truth, one URL per watch.

Case 18k Yellow Gold
Dial Emerald sunburst
Strap Cognac alligator
Indicative price (AUD) $38,900

// concept only — no checkout. Prices are illustrative.

05 — Engineering highlights

Where the craft lives.

E/01

The URL is the configurator

Options resolve to a Shopify variant on the server. The same function runs on the client for instant feedback — so a shared link renders the exact watch, priced, with zero layout shift.

app/routes/watch.$handle.tsx
// Server + client share one resolver — no drift between them.
export async function loader({ params, request, context }: LoaderArgs) {
  const url = new URL(request.url);
  const config = parseConfig(url.searchParams); // { metal, dial, strap }
  const { product } = await context.storefront.query(WATCH_QUERY, {
    variables: { handle: params.handle, country: context.market.country },
    cache: context.storefront.CacheLong(),
  });

  const variant = resolveVariant(product.variants.nodes, config);
  if (!variant) throw redirect(canonicalUrl(product, DEFAULT_CONFIG));

  return defer({ product, variant, config });
}
E/02

Materials tween, meshes don't

Changing metal never loads a model. We interpolate physically based parameters on the GPU — colour, roughness, clearcoat — over 600ms, synced to the UI spring.

configurator/materials.ts
const METALS: Record<Metal, PBR> = {
  gold:  { color: 0xe6bb5c, metalness: 1, roughness: 0.18, clearcoat: 0.4 },
  steel: { color: 0xd2d6dc, metalness: 1, roughness: 0.24, clearcoat: 0.2 },
  black: { color: 0x1c1c21, metalness: 0.9, roughness: 0.42, clearcoat: 0.6 },
};

export function tweenMetal(mat: MeshPhysicalMaterial, to: Metal, ms = 600) {
  const from = snapshot(mat), target = METALS[to];
  return animate(ms, springEase, (t) => {
    mat.color.lerpColors(from.color, tmp.setHex(target.color), t);
    mat.roughness = lerp(from.roughness, target.roughness, t);
    mat.clearcoat = lerp(from.clearcoat, target.clearcoat, t);
  });
}
E/03

3D that waits its turn

The hero ships as a 38KB AVIF poster. WebGL boots only after the page is interactive and the canvas is in view — on slow devices it never boots at all.

configurator/boot.ts
export function bootWhenWorthIt(canvas: HTMLCanvasElement) {
  const cheap = navigator.hardwareConcurrency <= 4 || saveData();
  if (cheap || !supportsWebGL2()) return; // poster stays — still sells

  const io = new IntersectionObserver(async ([entry]) => {
    if (!entry.isIntersecting) return;
    io.disconnect();
    await idle();                       // never compete with INP
    const { mountScene } = await import("./scene");
    mountScene(canvas, { dpr: Math.min(devicePixelRatio, 2) });
  }, { rootMargin: "200px" });
  io.observe(canvas);
}
06 — Targets & results

Numbers we build to.

Build targets and lab benchmarks for this concept — the budgets we'd contract on a real engagement.

  • Target · p75 4G0.9sLargest Contentful Paint
  • Benchmark · Pixel 6a60fpsConfigurator frame rate
  • Budget1.2MBTotal 3D payload
  • Scope36Variants, one URL each
07 — Stack

The toolkit.

Storefront

  • Shopify Hydrogen
  • Remix
  • React 18
  • TypeScript

3D

  • Three.js
  • Draco
  • KTX2 / Basis
  • Blender

Platform

  • Shopify Plus
  • Oxygen edge
  • Sanity
  • Klaviyo

Quality

  • Playwright
  • Lighthouse CI
  • RUM vitals
  • axe-core
Next project — 02 / 03 Pulse Native fintech · SwiftUI + Kotlin