The Product Design Process I Use, From Research to Shipped Code

The product design process in 7 steps, each with a real example: 13% to 65% activation, 95% of users who never used the product alone, and shipped code.

Written by
Ayoub Kada
Published on
November 19, 2026
Read time
15 min
Category

The product design process is the path from a vague problem to something real people use: understand the person and the business, define the one problem worth solving, map the flow, design the key screens, build it, then measure and adjust. That is the short answer. The honest answer is that the product design process I use today has seven stages, it ends in shipped code instead of a handoff file, and I almost never run it in a straight line. I have used it as the first design hire at a seed-stage AI company, as the only designer on an energy app for 200k+ households, and as lead designer on the creator platform built by the team behind MrBeast. Below is each stage, with a real example of what it looked like and what it produced.

What is the product design process?

It is a repeatable way to reduce risk. Every stage exists to answer one question before you spend money on the next one. Are we solving a real problem? Is it the right problem? Will people understand the solution? Can we build it? Did it work?

Most diagrams you will find show five or six boxes in a row: research, define, ideate, prototype, test. The best known version is the Double Diamond from the UK Design Council, which splits the work into discover, define, develop and deliver. Those models are correct, and I still think in diamonds: open up, then narrow down, twice.

What the diagrams leave out is the part that decides whether the product is any good. They stop at "deliver", as if the design is done when the file is done. In my experience the design is done when a real person completes the task in the real product and comes back the next day. So my version keeps going past the file, into the codebase and into the numbers. If you are new to the role itself, start with what a product designer does, then come back here for the how.

The 7 product design process steps I use

Here is the whole thing in one table. The examples are from my own case studies, and every number in it is published on my site.

StageThe question it answersWhat I doReal exampleWhat comes out
1. Find the question behind the requestWhat do people want that they are not saying?Listen to how users describe their day, not the feature they ask forViewStats creators asked for analytics. They wanted confidence about what to make nextOne sentence the team repeats
2. Research with the access you haveWho is this for, and what blocks them?Interviews, analytics, community channels, support requests, surveysGreenely: a Facebook group of 2,000+ members. Accern: research through the customer success teamEvidence, personas, a ranked list of problems
3. Define the problemWhich problem do we solve first?How-might-we statements, impact vs feasibility matrixAccern: 95% of users never used the product on their ownA problem statement and what is out of scope
4. Map the flowWhat is the shortest path to value?Storyboards, user flows, sketchesAccern: two separate products merged into one pathA flow everyone can read on one page
5. Design the key momentsWhat must feel right for this to work?Collect references, design the one or two moments that matter in FigmaViewStats onboarding: show value first, ask for trust secondHigh-fidelity frames and a system to extend them
6. Build it for realDoes it survive real data, real devices, real hands?Prototype in code, motion, interaction and sound includedReact components and pull requests at ViewStats, playable builds in my experimentsWorking software
7. Ship, measure, adjustDid behavior change?Funnel analysis, retention, support volume, direct feedbackChannel connection rate from 13% to 65%+The next round of the process

Step 1: Find the question behind the request

Every project starts with a request that sounds like a solution. Add a dashboard. Redesign onboarding. Put AI in it. The first job is to find the question underneath.

On ViewStats, the creator intelligence platform from the team behind MrBeast, the surface request was more analytics. Creators had numbers everywhere already. When I listened to how they talked about their work, the same question kept coming back: what should I make next? They were not looking for more analytics. They were looking for confidence.

That one sentence changed what we built. A feature like Outliers is not a chart. It is an answer to "what is working for channels like mine right now". I wrote more about that shift in dashboard UX best practices: clarity, not charts.

What comes out of this step is small on purpose: one sentence, in the user's words, that the team can repeat in a meeting when a feature starts drifting. If you cannot write that sentence yet, you are not ready for step 2. You are ready for more listening.

Step 2: Research with the access you actually have

Textbooks describe research as if you can always book twelve interviews next week. I have had that luxury once. The real skill is getting evidence from whatever access the company gives you. Three of my projects show three very different situations.

When users are everywhere. At Greenely, a Swedish energy app, users were easy to reach. There was a Facebook group with more than 2,000 members, and people would knock on the office door to complain or ask for a feature. I added Mixpanel so that what people said could be checked against what they did. Loud feedback and common behavior are not always the same thing.

When users are out of reach. At Accern, a no-code AI platform for financial organizations, the users worked at large finance enterprises. Very few were available for testing. So the research ran through the customer success team, who talked to those users every week: interviews with them, a usability survey, four personas, an empathy map. It is not perfect, and it beats guessing. The full story is in enterprise UX design: 95% of our users never used it alone and in the Accern case study.

When you have a community and data. At ViewStats the inputs were creator interviews, onboarding analytics, feedback from the Discord community, support requests and internal workshops. Five sources, each with a blind spot, each covering another's.

At Bitgrit (see the Bitgrit case study), a community of 30,000+ AI and data science engineers, I was the only designer in a company of about thirty people. The research was seven user interviews and a survey of twenty people, sorted with affinity mapping into three personas. Small, and enough to learn that people wanted fair rewards wherever they lived, a way to learn, and a place to show skills nobody had noticed.

My rule: use at least one source that tells you what people say and one that tells you what they do. If you only have one, say so in the findings.

Step 3: Define the problem before anyone opens Figma

Research produces a pile. Definition turns the pile into a decision.

At Accern the pile was heavy. The beta had been built on blue-sky concepts with no usability testing. There were two separate products, Titan for text analytics and XYME for predictive analytics. The language was full of terms like taxonomy, NLP and data store, which confused the people it was built for. And the number that defined everything: 95% of users never used the product themselves. The customer success team built use cases for them.

You cannot fix all of that at once. I used how-might-we statements to turn each finding into a question, then an impact and feasibility matrix to rank them with the team. The problem we chose was not "make the UI nicer". It was "make it possible for a non-technical person to build a use case without calling us".

The output of this step is a problem statement, the measure you expect to move, and a short list of what you are choosing not to solve. That last list saves more time than any other document in the process, because it is what you point to when scope grows.

Step 4: Map the flow before the screens

A screen is a moment. A product is the path between moments. I map the path first, with storyboards, user flows and rough sketches (at Accern I sketched in Procreate before anything went into Figma).

This is where the big structural calls get made cheaply. Merging two products into one path is a flow decision, not a visual one. So is deciding that a creator should see something useful before being asked to connect a YouTube channel.

Two questions guide this step. What is the shortest path to the first moment of value? And what happens in the in-between states: empty, loading, error, first time, hundredth time? Good design helps like a friend. Bad design leaves you in the middle, and the middle is almost always one of those states nobody drew.

If the vocabulary of this stage is new to you, my comparison of wireframe vs mockup vs prototype explains which artifact answers which question.

Step 5: Design the key moments, then the system

I do not design every screen at high fidelity. I collect references first, then design the one or two moments that decide whether the product works, and I design those properly.

At ViewStats, one of those moments was the request to connect a YouTube channel. Many creators signed up and never connected. Funnel analysis and research showed why: they did not understand what they would gain. The redesign was built around communicating value in onboarding moments, empty states and contextual prompts. The principle became a line I still use: show value first, ask for trust second. The details are in onboarding UX best practices from a 13% to 65% activation fix.

Once the key moments are right, the system follows. On ViewStats that meant one design system across web, mobile, marketing and a Chrome extension: typography, color, navigation, data visualization, tables, forms, empty states, variables and tokens. I covered how to do that without a platform team in design system for startups.

The order matters. A system designed before the key moments is a kit of parts for a product nobody has felt yet.

Step 6: Build it for real

This is the stage most process diagrams call "handoff", and the one I changed the most.

At ViewStats my role grew from lead product designer to design engineer. I worked in the codebase with Cursor, Claude Code, React, TypeScript and GitHub. I designed, prototyped, built React components, opened pull requests and reviewed the implementation. Iteration cycles got dramatically shorter, because the person who knew why a detail mattered was the person writing it. I explain the role in what a design engineer is.

Building is also where motion, interaction and sound get designed, because none of them can be judged in a static frame. My AI experiments are where I practice this: 17 playable builds, made mostly with Figma, Claude and the Figma MCP, plus SwiftUI, WebGL, three.js, physics engines, Rive, AI video for motion and ElevenLabs or Web Audio for sound. In one of them you tap a frozen bank card three times to shatter the ice, and the crack, the sound and the motion had to be tuned together. I broke it down in micro interactions examples, and I explain the sound layer in UI sound design.

You do not need to write production code to do this stage well. You do need to see your design running with real data on a real device before you call it finished. A prototype in code, a build from a developer you sit next to, a test release: any of them works. A static file does not.

Step 7: Ship, measure, adjust

The process ends where it started, with real people. The difference is that now you have behavior to look at.

After the ViewStats onboarding redesign, the channel connection rate went from 13% to 65%+. At Accern, after the redesign, retention went up by 200%, with users checking the product two to three times a week and finding their way without customer success, and support tasks dropped by 82%. At Greenely the app went from an untested, PM-wireframed product to one with more than 20 integrations, a notification feed and clearer price signals.

Numbers are not the only signal. When ViewStats launched AI thumbnail tools, the reaction went far beyond the product. Criticism about the impact on artists and thumbnail designers spread across YouTube and social media, and the BBC covered it. The lesson I took: product decisions do not exist in isolation, and "measure" has to include how the people around your users are affected. I wrote about it in AI ethics in design.

Whatever you learn here goes straight back to step 1. That loop is the process. The seven steps are just one lap.

Product design process with AI: what changed and what did not

"Product design process with AI" is one of the most searched versions of this topic, so here is what I see in my own work.

What got faster. Production. At ViewStats, a set of AI tools (thumbnail generation, text to thumbnail, face swap, variations, AI titles, thumbnail testing) went from concept to launch in roughly two weeks. In my experiments, a Figma frame goes to Claude through the Figma MCP and comes back as a working build that I then tune. Steps 5 and 6 have started to overlap: I often change the design in the middle of the build, because seeing it run tells me something the frame could not.

What moved. The handoff. When the designer can build, the file stops being a deliverable and becomes a brief. My whole workflow for that is in my AI design workflow from idea to App Store.

What did not change. Steps 1 to 3. No model knows that your users want confidence instead of charts, or that 95% of them never touch the product alone. AI also adds a design problem of its own. On the ViewStats AI tools, the hardest part was not the interface. It was designing trust: what the tool did, what it would not do, and how much control the creator kept.

There is no magic prompt. A model handed a vague request produces the average of everything it has seen. A model handed a clear problem, a mapped flow and two well-designed moments produces something close to what you meant. AI rewards the first half of the process. It does not replace it. I go deeper on that in will AI replace product designers.

How the process bends at different companies

The seven steps stay. Their weight changes.

As the only designer. I have been the first or only designer three times. There, steps 2 and 3 are compressed and you lean on whoever talks to users most, like support, sales or the founder. The risk is skipping definition because everyone is in a hurry. I wrote about surviving that in founding designer: what I learned being the only designer three times.

In B2B and enterprise. Step 2 is the hard one. Your user and your buyer are different people, access is limited, and jargon hides confusion. Plan for proxy research and say clearly where the evidence is thin.

In consumer products at scale. Step 7 becomes the strongest tool. With hundreds of thousands of users you can see behavior quickly, so you ship smaller and learn faster. The ViewStats Chrome extension, which put insights inside YouTube instead of a separate tab, grew to 200,000+ users, and that growth was itself the research. More in Chrome extension UX design.

In a concept or experiment. Steps 1 to 3 can be a single afternoon of collecting references and deciding the one feeling you want. Steps 5 and 6 take almost all the time. That is fine, as long as you do not present a concept as validated.

Where a product design process goes wrong

  • Treating it as a checklist. Running every method to look thorough. Each method should answer a question you actually have.
  • Research theater. Personas that never change a decision. If a finding does not change the flow, it was not a finding.
  • Skipping definition. Going from interviews straight to screens. This is how teams ship a beautiful answer to the wrong question.
  • Designing every screen, tuning none. Forty average screens lose to two moments that feel right and a system that extends them.
  • Stopping at the file. If nobody on the design side checks the build, the design that ships is whatever survived translation.
  • Measuring only the launch. Activation is one number. Retention, support load and how people talk about the product are the rest.

This process also has limits. It assumes you can reach some form of evidence and ship in rounds. In hardware, regulated medical products or anything with long certification cycles, the build and measure stages look very different, and I would not copy mine as is.

Product design process FAQ

What are the steps of the product design process?

The version I use has seven: find the question behind the request, research with the access you have, define the problem, map the flow, design the key moments and the system, build it for real, then ship, measure and adjust. Classic models like the Double Diamond group these into discover, define, develop and deliver.

What is an example of a product design process?

The ViewStats onboarding is one. Creators signed up but did not connect their YouTube channel. Funnel analysis and research showed they did not see what they would gain. The flow was redesigned to show value first through onboarding moments, empty states and prompts. The channel connection rate went from 13% to 65%+.

How long does the product design process take?

It depends on scope, access to users and how fast you can ship. One real data point: the ViewStats AI tools went from concept to launch in roughly two weeks, on a product that already had research and a design system. A new product starting from zero needs longer for the first three steps. Be wary of anyone who quotes a fixed number without asking questions.

Is the product design process the same as design thinking?

They overlap. Design thinking is a mindset and a set of methods for understanding people and exploring ideas. A product design process also has to handle business goals, technical constraints, a design system, the build and what happens after launch. I use design thinking methods inside steps 2 to 4.

How does AI change the product design process?

It speeds up production and blurs the line between designing and building. It does not find the real problem or decide what is worth solving. In my work, the first three steps are unchanged, and the last four happen faster and closer together.

Who owns the product design process?

The product designer leads it, with product managers and engineers involved from step 1, not invited at the end. When the designer can also build, the same person can carry a decision from research to code, which is where a lot of quality is usually lost.

Go deeper

Each stage has its own article with the full story:

Use it on your product this week

Take the feature your team is about to start. Write the one-sentence question behind it in your user's words. Name your two evidence sources, one for what people say and one for what they do. Write what you are not solving. Then pick the two moments that must feel right. If you can fill those four lines, you have a process. If you cannot, you have found where the risk is.

If you want someone to run this with your team, from research to shipped code, you can hire a product designer who does both, or read through my product design case studies and the ViewStats case study first.

If you have a web or mobile app idea in mind or you need some advice about product design, feel free to get in touch ✉️