Try It On Before You Buy It: Virtual Fitting for Online Fashion

I joined Dopplr as the only designer, and worked directly with the CEO and CTO to design a virtual try-on that runs in the browser. We were starting from zero. No product, no design system, no earlier version, no user flows.

So the work was not only designing screens. Along with the founders, I helped decide what the experience should be, and then designed the flows, interactions and motion for it.

Role User Experience Designer
Duration Jul – Oct 2022 4 months
Team Sresht Agarwal (CEO), Shubham Singh (CTO), Udit Kumar (Dev)
Dopplr overview

Results

  • Built from zero. A browser-based virtual try-on, with no existing product, design system or flows to start from.
  • Designed for trust. The avatar updates live as you enter your measurements, so you see yourself before giving more details.
  • An interface that gets out of the way. I removed the always-visible controls, and fit data became something you turn on, not a layer sitting on top of the garment all the time.
  • First project as the only designer. I worked with the CEO and CTO from product definition till motion design.

What I Owned

As the only designer, every part of the experience was mine. There was no previous designer to hand over, and no component library to start with.

  • Product definition: deciding the core flows and decisions with the CEO and CTO, before any screen existed
  • User flows: the full journey, from onboarding to creating the avatar to checking the garment
  • Interaction design: how people control a 3D object inside a browser, where there are no standard patterns to follow
  • Motion design: loading states, micro-interactions and transitions in ProtoPie and Jitter
  • Prototyping: high-fidelity prototypes for founder reviews and developer handoff
  • Design system: components, tokens and patterns, made from scratch as the product took shape

The Problem Space

The hardest part was trust, more than the technology. Virtual try-on only works if people believe what they see, and that does not come from nice visuals only. The avatar has to feel close enough to your body that you believe the fit. And the interface has to get out of the way fast, so you are actually looking at the garment.

The real challenge
People have to believe what they see.

To get there, I had to make trade-offs all through the project. How many measurements to ask before showing a result. How to show fit data without covering the garment. How much interface to show before it starts fighting with the 3D view.

Some hard limits shaped every decision:

Browser-only

Everything had to run inside the browser, which put real limits on rendering and scripting.

No consistent environment

It had to work across different ecommerce sites, and every site is different.

Consumer-grade performance

It had to run well on the devices normal shoppers use, not only on developer machines.

Garment stays the focus

The 3D garment had to be the main thing on screen, always.

Avatar Creation

Most people don't know their exact body measurements. If you ask too many questions before showing anything, people leave. If you ask too few, the avatar doesn't look right and they don't trust it. So the question was, what is the smallest set of inputs that gives a believable avatar, fast enough to keep people interested?

I tried a few directions.

Guided flow

Step-by-step measurements

People felt confident about what they entered, but it took longer before they could see the avatar.

Size chart

Standard size shortcut

Faster, but every avatar looked too similar to feel personal.

Hybrid

Size plus adjustments

Looked promising, but it made two steps, which added friction without making the avatar noticeably more accurate for most people.

In the end I went with a progressive flow, where the avatar updates live as you type in values. You don't have to finish a form to see something. Enter a few measurements, watch the avatar change, and decide if you want to refine more. I was designing for one moment: you look at the avatar and think "that's roughly me". Once that happens, the rest of the experience feels worth trying.

During this phase I worked closely with the CTO to understand which measurements the 3D system could actually use to make avatars look different from each other. That ruled out some of the simpler ideas. With size only, avatars looked too similar across people, and then nobody would trust the fit.

The Try-On Interface

The main problem here was that the interface was fighting with the garment for attention.

Persistent UI chrome

My early concepts had control panels always on screen, visible toolbars, and a labelled button for every action. In design reviews it became clear that people were reading the interface instead of looking at the clothes. The UI was pulling attention away from the 3D canvas, and that canvas was the only thing that really mattered.

So I removed the always-visible controls. Only the canvas and the garment stayed. Controls show up based on what you are doing: drag to rotate, scroll to zoom, hover for options. I cut down the labels or replaced them with motion that shows the action. The interface became something you pass through on the way to the garment, not something you have to manage.

This needed close work with the CTO and developers the whole time. We cut a few concepts because they needed extra rendering or scripting that slowed the frame rate on normal devices. Animations always running, layered UI, complex state logic, all of these had a real performance cost in the browser. The final interface was much lighter than my early explorations. Having to justify the cost of every element actually made the design more focused.

Dopplr Product Prototype

Fit Visualization

Fit data is what made the try-on useful, more than just how the clothes look. Where the garment is tight, where it has room, where it might feel uncomfortable after some time, this is the information that helps someone decide to buy. Showing fit was not the hard part. Showing it without overwhelming the garment was.

Persistent heat map overlay

In practice, the heat map always took over the screen. The colour layer made the garment look flat, fought with the fabric texture, and looked alarming whatever palette I used. People looked at the colours and not at the clothes underneath, which is opposite of what we wanted.

I tried many colour systems, opacity levels and ways to turn it on. A softer palette was less scary but harder to read. Outlines instead of fill looked cleaner, but on smaller garments you couldn't tell exactly where the problem was. The real issue was that it was always on. Fit data shown all the time felt like a warning, not a tool to inspect.

We also ran a pilot with real shoppers. They said the experience felt incomplete without a clear answer on which size to buy. So we made a clear size recommendation the main result, and moved the detailed fit information to a layer you open when you want it.

In the final version the heat map is optional: off by default, one tap to turn on, easy to close. People see the garment first, and check the fit when they are ready. I tested the colours across different garment types and render conditions, so it stays readable without making the 3D look flat. As a second tool and not the default view, it adds value without taking over.

Motion as Feedback

Loading 3D in a browser takes time. That is just the reality, and the design had to deal with it. So the question was not how to hide the wait, but what to show during it.

I designed loading states in the product's own visual style, so people could understand what was happening. When the avatar is being generated, you see it taking shape. When a garment is loading, you see the draping starting. The motion tells you what the system is doing, not only that it is busy. In a product where you have to wait for a render to get the payoff, the loading state is part of the experience.

Same thinking went into the micro-interactions. Every state change moves with a direction and a reason. Swapping a garment moves differently from zooming in. Transitions show how two states are connected, instead of only filling the gap between them. The goal was a product that feels responsive, but never pulls your eyes away from the canvas.

Motion as Feedback

What I Learned

This was my first project as the only designer from the very first conversation. No patterns to inherit, no senior designer to review my work, no component library. Every decision was the first decision made about that part of the product. So there was nothing to compare against, only the limits of the problem and feedback from the people I was building with.

Working directly with the CEO and CTO changed how I think about design in early-stage products. Most decisions had pressures pulling in different directions: what users needed, what was possible in a browser, and what the team had time to build. I learned to talk about design decisions in terms of what is feasible, not only what is nice to have. The CTO's feedback on performance shaped choices I would have treated as purely visual in other projects.

Designing a 3D product for the browser also taught me that interface choices have a cost. Animations that always run, layered UI, complex logic, all of these affect rendering. I started making these trade-offs early, instead of finding out during development. That made working with engineering more productive, and less about fixing things later.

What I would do differently is test more during avatar creation. Most feedback in that phase came from internal reviews with the founders. We moved fast, which was right for where the product was, but some usability problems in the measurement flow came up later than they should have. Next time I would push for at least one round of testing with outside users before locking the onboarding, even an informal one. Changing the input model late cost much more than testing early would have.