Résumé

Ikarus DeltaCase study

Ten rounds of revisions, gone

Every 3D product configurator was hand-built from scratch and took ten to fifteen rounds of back-and-forth to finish. We replaced that with one platform, and a three-week build became a seven-day one.

The Ikarus Delta scene editor — parts tree on the left, the 3D model in the centre, controls on the right
Client
Ikarus Delta
Role
Product designer — discovery and early structure
Timeline
Jun – Jul 2024
Focus
Platform design, Workflow design, Design systems, 0 → 1
Read
8 min

Overview

Ikarus makes 3D products that shoppers can change right on a shop’s product page: a sofa you can re-cover in another fabric, a lamp you can switch to brass. Each one of these is called a configurator. Ikarus Delta is the platform we designed to make them.

Through 2024 Ikarus won clients faster than its way of working could keep up. Every configurator was built from nothing (new models, new code, new screens), and every one took ten to fifteen rounds of fixes before it went live.

With Dipanshu Saini, the other designer on the team, I worked through the discovery, the platform’s structure, its interface and its component system. I was on the project for its first five weeks, until 4 July 2024, when I left Ikarus to start a master’s.

The result was a single platform that three very different groups could work in: the 3D artists making the models, the managers tracking the projects, and the developers putting them on clients’ websites. Building a configurator got 70% faster.

The short version

The problem

Each configurator was built from scratch and went through ten to fifteen rounds of fixes, mostly because artists checked their work in one program and it then looked different on the real website.

What we did

A month watching each team at work. Then one platform, with no coding needed, where the model is checked looking exactly the way shoppers will see it.

What changed

Three weeks per configurator became seven days. Projects delivered on time went from 40% to 90%. The rounds of fixes didn't get shorter; they stopped being a step at all.

70%faster to build
40→90%on-time delivery
10–15revision rounds removed
5 wksmy part, of 3 months
A pendant lamp configurator on a client storefront, with finish swatches beside the model
LightingFinish and shade, swapped live
A sofa configurator with a grid of upholstery swatches
SeatingUpholstery across a large swatch set
A height-adjustable desk configurator with size and top options
DesksSize, top and frame
An apparel configurator on a product page with colour options
ApparelSame engine, different category

This is what the output looks like on a client’s storefront. Four categories, four separate builds, and before the platform, four times the work.

My role

The project

An internal platform at Ikarus 3D, June to the end of August 2024. Design was two people: Dipanshu Saini and me. Around us: one co-founder running 3D, one product manager and two developers. I was on it until 4 July.

What I owned

Discovery with the three teams, the platform's structure, the interface and the component system, worked through together with Dipanshu. After I left, the work was getting it live: connecting it with the developers' code, and small changes along the way.

Tools

Figma for wireframes and screens. Card sorting on a whiteboard, where the 3D artists grouped settings the way they think of them. Hero UI, a ready-made set of interface components, chosen with the developers.

What I delivered

The research findings and the mind map that traced them to one cause, a close look at competitors' tools, the editor, projects and materials screens with written feedback on each, and ready-made themes for configurators.

The problem

The problem showed up in a monthly meeting between teams, not in any number. Two groups described the same project from opposite ends, and neither of them was happy.

The 3D artists were tired of feedback loops that never seemed to close. The developers were tired of rebuilding the same features for every new client. Between them sat a handoff where nothing the developers did could start until the artists were finished, and the artists were rarely finished when they thought they were.

An illustration of a 3D artist and a developer at either end of one tangled line, each surrounded by revision notes and warnings
Two teams on one project, joined by a handoff nobody could see the whole of.

The product was strong. The way it got built was not.

Who
The 3D artists, developers and managers inside Ikarus who build a configurator for every new client.
Need
A way to go from a set of 3D models to a finished configurator, ready to put on a client's website, without starting from zero and without ten rounds of fixes after "done".
Because
Every project started from scratch. And the artists approved their work in a review program that drew the 3D model differently from a web browser, so what they signed off looked wrong once it was on the website. Fine for three clients a year. It is what stops you taking on a fourth.

How might we give three teams one place where a configurator lives, so checking it, building it and delivering it stop happening in different places?

What discovery found

Goal

Find the problems people had stopped reporting, the ones everyone had come to accept as "just how long this takes".

What we did

About a month watching each team's real working day, rather than interviewing them about it, plus a card-sorting session with the artists on the settings nobody could find.

What we found

Six complaints from two teams, each one a cost somebody had quietly accepted. Put side by side, they all came from one cause: there was no single place where a configurator lived.

What it changed

The fix could be a single platform rather than six separate improvements.

A whiteboard covered in coloured sticky notes from a card-sorting session on camera and environment settings
Card sorting with the 3D artists on camera and environment settings, the controls nobody could find. Grouping them the way the artists think about them, rather than by how the software works underneath, is what made that panel usable.

For the 3D artists

  • Two different pictures. Models were checked and approved in a testing program that didn't draw them the way a web browser does, so work that had passed came back wrong once it was on the website.
  • Deadline pressure. Because revision rounds started after the work was supposedly done, the fixing happened late at night against a delivery date.
  • Workflow chaos. Assets and change requests were tracked across several tools, so nobody could say where a model was without asking a person.

For the developers

  • Reinventing the wheel. Around 60% of a developer's day went on rebuilding features that already existed somewhere else in the company.
  • The handoff marathon. Ten to fifteen rounds of back-and-forth per configurator, treated as normal rather than as a problem.
  • Maintenance over progress. More time went on fixing what had already been delivered than on building what was next.

Both sides were describing one problem from two ends. A configurator lived as a model in one tool, a spec in another, a chat thread in a third, and code in a fourth, and every gap between them was another round of fixes waiting to happen.

A mind map radiating from a central 'finding cause' node, grouping the pipeline's failures by where they originated
Mapping the findings against each other rather than listing them. Six complaints from two teams collapsed into one cause, which is the only reason the fix could be a single platform.

The goal

One environment. No code. Nothing built twice.

We looked at how other configurator tools already handled this, Zakeke and Combeenation in particular, to sort the ideas worth keeping from the traps.

A teardown board of a direct competitor's configurator, screen by screen with annotations
DirectPlatforms selling the same thing we were about to build
A teardown board of indirect competitors, covering adjacent product-customisation tools
IndirectAdjacent tools solving one piece of it well

Worth keeping

  • Editing the model directly rather than through form fields beside it
  • Hover states that explain what a control actually does
  • Real-time feedback as settings change
  • Product details (metadata) filled in automatically instead of typed

Worth avoiding

  • Interfaces dense enough to need a training session
  • Control setup that becomes its own busywork
  • Anything that requires the user to write code
  • No way to start from anything but a blank file

That left a gap: one tool where everything happens in one place, with settings anyone can set up without code, and templates to start from. We set four principles to judge every screen against:

Simplify

Shorten the path from a set of models to a finished configurator, ready for a website.

Empower

Let a non-technical user do work that previously required a developer.

Maintain

Make the result something you can change after it goes live, without building it again.

Reuse

Anything made for one project should be there for the next one.

How the editor is organised

Goal

Decide the layout of the editor, the screen artists would spend most of their day in.

What we did

Looked at where the output ends up. A configurator's final home is an online product page: model on one side, options on the other.

What we found

The artists were already fluent in that layout, because it is the one their work ships into. And if the editor draws the model the same way the website does, what an artist approves is what a shopper sees.

What it changed

The editor is laid out like the product page, part for part, and draws the 3D model with the same software the shop uses. That is what stopped the rounds of fixes from happening at all.

Two wireframe panels side by side: an e-commerce product page and the 3D editor, with matching regions annotated
The product page on the left, the editor on the right, region for region. Model in the centre, options on the right rail, thumbnails down the side.
Scene
Projects
Materials
Controls
Embed

The scene editor, mirroring where the output ends up

  1. The model, livedrawn exactly as the shopper will see it
  2. Options panel, rightexactly where a product page puts them
  3. Environment & lightinga small pop-up panel, so the model stays in view
  4. Theme & versioningin context, not on their own screens

Review it where it will actually live.

Most of the ten to fifteen rounds were not disagreements about the work. They came from the model looking different in two programs, found out late.

The platform, screen by screen

  1. ProjectSet up the catalogue
  2. SceneLoad and stage models
  3. MaterialsPull from the library
  4. ControlsNo-code, live preview
  5. EmbedOne line pasted into the website
The 3D scene editor: parts tree on the left, the model rendered centre, product details and controls on the right
The scene editor — the model drawn exactly as it will look on the shop's website, with the options panel where a product page would put it. Parts on the left, controls on the right, and a preview button that opens the real thing rather than an approximation of it.
The projects view: a grid of configurators grouped by client, each with a status
Projects and files — a layout that still works once there are more than a handful of clients, so finding a model stops being a question you ask a colleague. Status sits on the card, which is what took progress-chasing out of chat.
The material library: a grid of wood and fabric swatches with names and variants
The material library — the reusable layer of the whole system, and the thing that made every later project cheaper than the last. This is the piece we got wrong first: competitors organise their libraries around models, but Ikarus builds each model to order and reuses the finishes (fabrics, woods, metals), so the library had to be built around materials.
A control being created in a modal over the scene, with option rows and part pickers
Controls — the logic of a configurator set up in a dialog, with the result appearing on the right panel as you build it. No scrolling, no code. This is the piece that meant artists no longer had to wait for a developer.

Frequent adjustments (lighting, background, theme, version) sit in small pop-up panels rather than on their own screens, so the model never leaves the frame while you change it.

The scene editor with an Edit Part popover open beside the model
Edit in placePart editing as a popover over the scene, so the model stays in view while you change it
The material library with a colour picker open over a swatch grid
Materials, up closeFinishes and variants edited against the grid rather than on their own screen
A material group properties dialog with roughness and metalness sliders beside a live sphere preview
Material propertiesHow rough or metallic a finish is, shown on a live sphere, so it is judged by eye, not by number
The projects grid with a context menu open on one configurator card
Project actionsStatus on the card, actions in a menu. No detail screen needed to see where something is

Watch it in motion: the Delta configurator, end to end ↗

Getting there

None of these landed first time. Each screen went through a wireframe, a round of written feedback from the team it was for, and a rebuild.

Scene editor. The first layouts put every setting on screen at once. Each round took something off the canvas until the model had the room.

An early scene editor layout crowded with stacked panels, flagged with a red note about the chaotic layout
First passToo much at once. The artists hunted for controls instead of creating them
A second round of scene editor layouts compared side by side
AlternativesSeveral arrangements of the same panels, tried against each other
The settled scene editor wireframe with a placeholder model and stacked panels
SettledParts left, model centre, product and controls right
A wireframe of the scene editor annotated with green critique notes explaining each decision
Feedback was written on the wireframes, with the reasoning next to each screen, not given in a meeting. That is also what made the handover survive my leaving: the argument for each layout was on the artboard rather than in my head.

Projects. One flat view of every product stopped working the moment an organisation had hundreds of them.

An early projects screen with a red note on how a single flat view breaks down at hundreds of products
First passEvery product in one list, no way to group them
A projects screen with an organisation panel opening onto a grid of product thumbnails
GroupedOrganisations first, products inside them
The settled projects wireframe: organisation rail, project list and a grid of configurator cards
SettledStatus filters and a card per configurator

Materials. A second sidebar for material categories split the screen in two and hid the textures themselves.

An early material library with a double sidebar, flagged with a red note about wasted space
First passTwo sidebars fighting for the same space
A material library with one category list and a texture grid with a settings panel
One listCategories folded into a single column
The settled material library inside a project, with a colour picker open over the texture grid
SettledMaterials live inside the project, edited in place
The projects wireframe annotated with green notes on each change
Projects, annotatedWhy each change was made, written on the screen
The material library wireframe annotated with green notes on inline editing and the colour picker
Materials, annotatedInline editing and a quick colour picker, argued on the artboard

Design language

Borrowed on purpose. Three months is not long.

AaInter — inherited from Hero UIRestyling the type would have gained nothing and cost two weeks
Components
Hero UI, chosen with the developers over building a custom set: the most complete coverage, actively maintained, and it shipped both themes out of the box.
Themes
Light and dark from day one, because the 3D artists work against dark backgrounds and the managers do not.
Templates
Configurator themes are templated per product category, so a new client starts from something rather than from a blank file.
Hero UI open source component kit
Hero UIChosen: widest coverage, both themes, actively maintained
Chakra UI open source component kit
ChakraStrong, thinner coverage of the dense controls we needed
Material UI for Figma
Material UIToo opinionated to disappear behind a 3D viewport
shadcn/ui component library
shadcn/uiMore assembly than the schedule had room for

Hero UI, themed to the brand

Primary#CF462A
Secondary#FEF3F0
Foreground#11181C
Background#FFFFFF
Divider#D4D4D8

Status

Success#17C964
Warning#F5A524
Danger#F31260

Picking a component library reads like a visual decision and is really a scheduling one. It set how fast two developers could move for three months, which mattered more than any amount of custom styling would have.

The one place the platform gets styled is the output. Configurator themes are templated per product category, so a client’s storefront gets something that looks like their brand rather than like our tool.

A configurator theme applied to an upholstered sofa product page
Upholstery
A configurator theme applied to an armchair product page
Seating
A configurator theme applied to a leather bag product page
Accessories
A configurator theme applied to a wooden sideboard product page
Casegoods
A configurator theme applied to a standing desk product page
Desks
A configurator theme applied to a lounge chair product page with colour swatches
Lounge

Decisions and trade-offs

A material library, not a model library

Decision
Invest in a deep, well-organised library of materials and textures rather than a library of finished models.
Because
The original plan assumed models would be reused between clients. They are not: the team builds each one from scratch against client photographs. The genuinely reusable layer was one level down, in the materials. Finding that out changed the roadmap.
Result
A narrower feature, and a far more useful one. The library keeps growing: each project leaves the next one more to start from.

Ship on someone else's components

Decision
Use Hero UI as it comes, typeface included, rather than design our own set of components.
Because
Two developers, three months, and an internal tool whose value is entirely in what it does. A custom set would have looked more impressive, and launched later.
Trade-off
The platform does not look like anything in particular. For a tool used by four people inside the company, that was the correct thing to give up.

Fit the spreadsheet instead of replacing it

Decision
Integration is a single embed link, pasted into the spreadsheets the team already tracked projects in.
Because
The elegant answer was to absorb tracking into the platform. The workable answer was to require nobody to change how they already worked.
Result
Adoption needed almost no training and no rollout plan, which for an internal tool is most of the battle.

In-platform messaging

Cut
Decision
Dropped from the first version. Artists and developers keep talking wherever they already talk.
Because
It was the obvious nice-to-have and the obvious thing to lose. Shipping something the team could actually use beat shipping something complete.
Trade-off
Conversations stay outside the platform, which is a real cost, just a smaller one than launching three months late.

Outcomes

The old process: client onboarding, work delegation, then model creation and web implementation caught in an endless loop before delivery
An endless loop. Model, review, implement, find the mismatch, go back. It stopped when the deadline arrived.

How things improved

70%

Faster configurator builds

Three weeks became seven days, and the ten to fifteen rounds of revision went away as a stage.

90%

Delivered on time

Up from 40% of projects landing when promised. Predictability mattered as much to the business as speed.

Two teams, two tracks

Artists build configurators without waiting on developers, and developers stop waiting on model updates.

A sales tool, by accident

Configurations could be shown live in a pitch instead of played as a video, which helped win larger clients.

Nothing new to learn

The 3D artists kept their spreadsheets and simply pasted a link in when a configurator was done.

What I learned

What we achieved

One platform that replaced a custom build per client, cut build time by 70%, and removed the revision loop as a stage rather than shortening it.

The biggest lesson

Watch the work, don't ask about it. The mismatch between the two programs was the single most expensive problem in the whole process, and nobody raised it in a meeting, because it had stopped registering as a problem. A month inside the work found it; a round of interviews would not have.

What I'd do differently

Check the assumption under the roadmap before drawing anything. An entire planned feature rested on models being reusable. They were not. The cheapest moment to discover that is before the first wireframe, and it was very nearly missed.

Going forward

Leaving a project cleanly is its own skill. I handed this over five weeks in. What made that work was that the discovery and the reasoning were written down rather than held in my head, and I now treat that as part of the job rather than an extra.

In short

This project replaced a custom build per client with one platform where a configurator is made, reviewed and delivered in the same place. It set out to remove a ten-to-fifteen-round revision loop and did so by making the place a configurator is checked the place it ships from, which took build time from three weeks to seven days and on-time delivery from 40% to 90%. My part was the discovery and the early structure, worked through with Dipanshu; the plain, paste-one-link way of connecting it is why it got used.

On this page

  1. 01Overview
  2. 02My role
  3. 03The problem
  4. 04What discovery found
  5. 05The goal
  6. 06How the editor is organised
  7. 07The platform, screen by screen
  8. 08Design language
  9. 09Decisions and trade-offs
  10. 10Outcomes
  11. 11What I learned

Next case study

Renderly · Ikarus 3D

A marketplace both sides trust

An online shop for files you 3D print at home. Artists sell their models and raise money for new ones; buyers see photos from other buyers, so they know a file will print before they pay. I designed the shop, the model page and the tool artists use to build a campaign.

Read it

More work

what it makes

and how long it took

so we watched

one cause, one fix

start where it ends up

then, the platform

none of it first time

the call that mattered

what we chose not to build

what changed

what I took from it

what’s next

Ikarus Delta · Platform design · Jun–Jul 2024

Ten rounds
of fixes, gone.

One place to make, check and ship the 3D products shoppers change on the page.

Scroll, and I’ll walk you through it

01 · What it makes

Change the product, right on the page.

  1. Lighting
  2. Seating
  3. Desks
  4. Clothing

02 · The loop

Round1of 10 to 15, for every product

3D artistsTired of feedback that never ended, and fixing things late at night before a deadline.
DevelopersTired of rebuilding the same features for every new client.

Fine for three clients a year. It’s what stops you taking on a fourth.

03 · Six complaints, one cause

3D artists said

Developers said

Approved here, wrong on the siteThe review tool didn’t look like the real website, so approved work came back wrong.
Fixes at midnightFixes started after the work was “done”, so they happened late, against a deadline.
Where is that model?Files and requests lived across several tools. Finding anything meant asking someone.
Building it all againAbout 60% of a developer’s day went on rebuilding things that already existed.
10 to 15 rounds, as normalThe back-and-forth on every configurator was treated as just how long it takes.
Fixing old workMore time went on fixing what was delivered than on building what’s next.
One causeThere was no single place where a configurator lived.A model in one tool, a spec in another, a chat in a third, code in a fourth. Every gap was a round of fixes waiting to happen.

04 · The goal

One place. No code. Nothing built twice.

1SimplifyFewer steps from a set of models to a live configurator.
2EmpowerSomeone who can’t code can do what used to need a developer.
3MaintainChange it after it ships, without rebuilding it.
4ReuseWhat one project makes, the next one can use.
Worth keepingEditing the model itself, not form fields beside itControls that explain what they doSeeing every change straight away
Worth avoidingScreens that need a training sessionSetup that becomes a chore of its ownAnything that needs code

Studied first: Zakeke and Combeenation, the tools already doing this.

05 · Review it where it ships

Where it ends up: a client’s product page

So the editor copies it

1122

1the same model, drawn the same way

2the options where the page puts them

What an artist approves is what a shopper sees.

06 · The platform

  1. 1Project
  2. 2Scene
  3. 3Materials
  4. 4Options
  5. 5Embed

07 · None of it landed first time

  1. The editor
  2. Projects
  3. Materials

Too much on screen at once. Each round took a panel away, until the model had the room.

One long list of everything. Now grouped by client, with the status on each card.

Two sidebars fighting for space. Now one list, edited in place.

08 · Materials, not models

The plan: reuse finished models

Sofa for client Abuilt from the client’s own photos
Chair for client Bbuilt from the client’s own photos
Lamp for client Cbuilt from the client’s own photos

They never got reused: each one is built to order.

What does get reused: fabric, wood, metal. Every project leaves the next one more to start from.

09 · What we chose not to build

ChosenReady-made parts

We used Hero UI, an off-the-shelf component kit, instead of designing our own. Two developers, three months: speed mattered more than looks.

Trade-offIt doesn’t look like anything in particular. Fine for a tool four people use.

ChosenA link, not a new habit

The team tracked projects in spreadsheets. So a finished configurator gives you one link to paste in there. Nothing new to learn.

Trade-offTracking stays outside the platform.

CutNo chat inside

Artists and developers keep talking wherever they already talk. Something the team could use soon beat something complete later.

Trade-offConversations stay outside the record.

Each one traded polish for getting there sooner.

10 · A loop becomes a line

Before: round and round until the deadline

After: each step finishes before the next one starts

21 daysto build one configurator, down from three weeks to seven days
40% → 90%of projects landing on time
No more roundsthe fixes stopped being a stage at all

11 · What I learned

1Watch the work, don’t ask about it.The costliest problem never came up in a meeting. A month inside the work found it.
2Check the plan’s assumption first.A whole feature rested on models being reused. They weren’t. Cheapest to find out before drawing anything.
3Write the reasoning down.It’s what let me hand this over after five weeks without it falling apart.
Bhupesh

Ikarus makes the 3D products you can change on a shop’s website. Here’s one, and what it took to make.

21days for one sofa 10–15rounds of fixes 0reused for the next shop

So we built one place to make them, where what the team approves is exactly what the shopper sees.

01 / 20

Let’s talk

Got a project, a role, or just want to say hi?
I’d love to hear from you.

What’s it about?

or find me on