Live demo · Passcode required for admin
The Maker's Studio
Configurator to factory floor, in one loop.
// TL;DR
Most "custom" e-commerce shows customers a flat 2D mockup. The customer guesses, the factory interprets, and what arrives doesn't match what was sold. The Maker's Studio closes the loop — the customer's real-time 3D configurator IS the manufacturer's reference IS the QA spec sheet. One source of truth from cart to ship.
The gap between what was sold and what was shipped kills custom-goods D2C.
Custom-goods returns happen overwhelmingly in the last mile — the customer expected one thing, the factory built another, and the spec handoff between them was a JPEG and a wish. I surveyed 14 small D2C founders working in customization; 11 named fulfillment ambiguity as a top-three cause of returns. The configurator wasn't the missing piece — those exist. The missing piece was the operational loop that connected the customer's 3D preview to the factory's manufacturing spec without a translation tax.
Two users, one loop.
The Maker's Studio is a two-sided product. The customer-facing surface is the configurator. The factory-facing surface is the admin dashboard that turns every order into a build-ready spec. The platform thesis is that both sides have to see the same artifact for the loop to close.
- D2C brands selling configurable physical goods who are bleeding revenue to return rates
- Small manufacturers fulfilling custom orders who currently work from JPEGs and customer-service tickets
- End customers (gift-buyers) who want to see exactly what they're ordering before they hit purchase
"What I ordered" ≠ "what I got" is the silent killer of custom-goods D2C.
I ran founder interviews with 14 small D2C brands in customization-heavy categories. The pattern was unmissable: existing configurators on the storefront side had no equivalent on the operations side, so factories worked from screenshots, JPEGs, or worse, free-text customer notes. The handoff tax produced returns, reshipping costs, and a measurable hit to repeat-purchase rates. Threadless and Customink had solved the configurator side and built their own internal ops tooling — proof the loop mattered — but no off-the-shelf solution closed it.
// Signals
- 11 / 14 D2C founders interviewed cited fulfillment ambiguity as a top-3 cause of returns
- Threadless, Customink, and other established players all built their own internal ops tooling for the same loop
- Factory-side operators consistently described the handoff as "JPEG and a prayer"
Close the loop. Same artifact, customer to factory. Refuse the catalog-expansion trap.
The strategic thesis was simple: the customer's 3D preview at checkout is the same object the factory builds from. No translation, no JPEG, no free-text note. The configurator is the source of truth for both sides. The companion thesis was operational: launch with three SKUs deep, not thirty wide. Custom-goods configurators die the moment they try to cover too many categories before the operational loop is bulletproof.
// We said NO to
- Launching with a broad catalog — three SKUs deep beats thirty SKUs wide
- Marketing "we have a 3D configurator" — the real story is "we close the loop"
- Third-party WMS — would have re-introduced the JPEG handoff we were trying to delete
- Customer-side payment optimization — checkout AB testing is for later; product-truth has to land first
Real-time 3D. Live price. Admin dashboard. One artifact across the loop.
The customer surface is a 3D configurator built on React Three Fiber — material, color, engraved text, all editable in real time with a live price that updates per choice. The artifact the customer commits to at checkout — geometry, materials, text, the literal 3D screenshot — is what the admin dashboard receives. The factory operator sees the customer's exact 3D, a manufacturing-ready spec sheet, and a fulfillment-state machine that tracks the order from received to shipped.
React Three Fiber renders the product live as the customer changes material, color, and engraved text. The price updates in the same render loop.
Pricing is a function of material × geometry × engraving complexity, computed client-side from a pricing table. No "request a quote" step.
At checkout, the configurator snapshot is stored — same artifact the factory operator sees. The loop is closed; no JPEG handoff.
Order list, per-order spec sheet, fulfillment state machine, and the customer's 3D preview embedded so the operator never has to imagine what was ordered.
Text engraving rendered live on the 3D product — exact font, exact size, exact placement. What you preview is what gets printed.
What we deliberately gave up — and what we kept in exchange.
A WMS would have shortened build time but reintroduced the JPEG handoff we were specifically trying to eliminate. The custom admin is the moat.
Going deep on three categories let the operational loop bake before we expanded. Catalog expansion is the death-by-a-thousand-cuts trap in this category.
Higher build complexity, but the 3D preview is the artifact that closes the loop. A 2D mockup would have left us right back in JPEG-and-prayer territory.
Live pricing forces a clean pricing model and pre-empts the friction of waiting. Worth the engineering investment to avoid the conversion drop.
Live demo. Loop validated end-to-end. Carrying the Formies lessons forward.
The demo runs publicly with the admin behind a passcode. The full handoff — customer configures, checkout snapshots the 3D, admin renders the same 3D, operator marks fulfilled — has been validated end-to-end. The next step is operational scale, which is precisely what Formies taught us we needed before we ever shipped a single configurator pixel.
What I'd carry forward.
// Stack