The UX Design process: Every step from discovery to launch

The UX Design process, from discovery to launch, in 7 steps: What to make, when you're done, and where AI helps without replacing judgment.

Design8 min

A design team was ready to ship the new website for a famous coffee brand.

Everything looked very polished.

I asked them a simple question: When a pastry sells out before pickup, what should the customer see?

They didn't have an answer.

They had spent weeks debating which fonts and colors to choose and forgot to think about logic and structure.

This article maps the full user experience design process in seven steps.

Learn each one of them to understand what to create, when you have finished, and where AI can help you under your supervision.

Every step you follow should answer one decision before you move to the next one..

The seven-step UX Design process

Recent industry surveys show that design teams report delays from unclear requirements and late changes after design looked finished.

The screens were never the problem.

The decisions behind them never shipped.

Step 1: Discover

Discovery answers one question: Is there a real user problem worth designing for?

Start with a short research plan that names your questions, audience, and method.

Build an evidence log from interviews, analytics, or field notes, and capture the jobs users describe in their own words.

You're done when you can state the primary user and their main job in one sentence each, and when at least three independent signals point to the same pain.

The usual failure here is a discovery deck that never connects to a decision.

Keep what you write short and tied to what you'll design next. AI can summarize the content you analyzed and created but you have to choose which problems stay in scope.

For method selection without overload, also read UX research methods that inform better design decisions.

Step 2: Define

Define answers one question: What problem are we solving, for whom, and how will we know we succeeded?

Write a problem statement a user would recognize. Add success criteria you can measure when possible, like completion rate, time on task, or conversion on the core flow.

List what is in scope for v1, what is out, and the constraints that bound the work: Brand, legal, tech, and timeline.

You're done when stakeholders can repeat the problem and success criteria without slides, and when out of scope is written down instead of implied.

The usual failure here is a definition that stays abstract while high-fidelity pages are already in flight.

Keep the bet visible in plain language everyone can reference.

AI can stress-test problem statements and spot contradictions in scope, but you still own the trade-offs.

Step 3: Structure

Structure answers one question: How do people find, understand, and move through content and tasks?

Build a user flow for the core job, and one for the happy path.

Define what's in the product and how users move through it.

You're done when a new teammate can trace the main task without opening visual design files, and when edge cases are named even if they are not designed yet.

The usual failure here is a diagram that no longer matches the pages in your file.

Keep structure and screens in sync as the source of truth.

AI can draft flow alternatives and suggest labels, but you still validate with a quick walkthrough.

Step 4: Design

Design answers one question: What should screens look and read like at the fidelity needed for the next proof?

Start with low-fidelity wireframes for critical paths. Then design UI for default, empty, error, loading, and success states on the core path.

Use real copy on primary actions and errors and responsive notes for each breakpoint you support.

You're done when the core path tells one coherent story, when states are designed or specified in writing, and when visual rules are consistent enough that dev is not guessing spacing and type screen by screen.

The usual failure here is a gallery of beautiful screens that don't connect into one task.

Design against the criteria from define, not against taste alone.

AI can generate layout variations and draft microcopy, but you still cut options with intent.

For baseline quality before launch, read Accessibility in UX Design: the basics every designer should ship with.

If you explore many UI directions, also read AI for UI Design exploration without endless variants starts with a criteria-first workflow.

Step 5: Prototype

Prototype answers one question: Can someone complete the core task in a realistic flow?

Build a clickable prototype for the primary path, a script for about five usability sessions, and a short list of assumptions you are testing.

Run sessions with target users on the task that matters, not a tour of every screen.

You're done when at least five people attempt the core task without you steering every click, and you have recorded where they hesitate, mis-tap, or misread labels.

AI can speed screen link-up and draft facilitator scripts, but you still run sessions and interpret what you hear.

Step 6: Test

Test answers one question: What must change before we treat design as ready for build?

Rank usability findings by severity. Assign owners to a prioritized change list, update screens or write specs for must-fix issues, and document what you are not fixing in v1 and why.

Close the loop against the success criteria from define: Met, partial, or deferred with rationale.

You're done when blockers are resolved or accepted with a written trade-off, and when the must-fix list has owners and dates.

The usual failure here is a report that never becomes tickets.

Turn findings into owned changes before dev starts.

AI can summarize session notes and cluster issues, but you still set severity and scope.

That is where the coffee brand's sold-out pastry question should have been closed: A designed empty state and message in the cart, not a guess mid-sprint.

Step 7: Deliver and launch

Deliver answers one question: Can engineering build and release this without reopening product strategy?

Package scope, states, behavior, responsive notes, and tokens need to be defined. Ship build-ready screens with clear version naming.

Add a launch checklist: Analytics events, error monitoring, support copy, and a rollback plan for critical paths. Record who approved what for release.

You're done when developers can implement edge states without default guesses in chat, and when QA can test against user tasks and not only pixel match.

The usual failure here is treating deliver as a Figma link sent. Handoff is decision transfer, not file transfer.

AI can generate checklists from flows and draft QA scenarios, but you still walk the build with dev.

For the handoff bundle itself, also read Design handoff done right: What developers actually need from you.

Action checklist

Write the primary user job in one sentence.
Publish in-scope and out-of-scope lists.
Map the core flow on paper before high-fidelity screens.
Design empty, loading, error, and success for the core path.
Test five sessions on the task that matters.
Turn top findings into owned changes with dates.
Hand off behavior and states in writing.
Confirm launch monitoring for the core path before release.

To embed AI across this sequence without chaos, also read how AI-first design workflows actually work step by step.

FAQs

What is the UX Design process?

The UX Design process is a repeatable sequence that moves from understanding user needs to launch-ready design. It ties each phase to a decision, outputs that support that decision, and clear done criteria so screens don't ship ahead of strategy.

What are the main steps?

Use seven steps: Discover, Define, Structure, Design, Prototype, Test, and Deliver for launch readiness. Steps loop when new evidence appears.

How is this different from the product design process?

The UX process focuses on user-centered design work through validated screens and handoff. The product design process adds ownership of direction, build, and post-launch learning across the whole product. Use UX steps when you're responsible for design quality through release.

What is a UX Methodology vs a UX Design process?

A UX methodology is a framework like Double Diamond or Lean UX. A UX design process is the step order you run on a project. Methodologies fit inside steps; they don't replace done criteria.

Where does AI fit into this?

AI speeds drafting, synthesis, and variation inside each step. It doesn't replace decisions on problem, scope, structure, or severity of usability issues. Treat AI output as input you review, not approval.

How much UX Research is enough before design?

Enough to choose a primary user and job and to challenge your assumptions. Three quality signals beat a large unread report. If research and design are the same person, limit discovery and write decisions in plain language.

What should be ready before launch?

Launch readiness means buildable screens, documented states, acceptance criteria for core tasks, and monitoring for the path that matters. It doesn't mean every future feature is designed.