Head of Product at a Series A fintech startup. Team of 11. Designers in Kyiv. Developers in Warsaw. PM in London. They decide to run a full UX redesign of their onboarding flow.

Discovery: three time zones, five Slack threads, no single source of truth. Research synthesis took four weeks instead of one because nobody agreed on what “done” looked like. Wireframes sat unreviewed for six days because the London PM was in back-to-back investor meetings. Usability testing got skipped entirely – “no time.”

They shipped. Onboarding drop-off went up, not down.

The problem wasn’t the team. The problem was running co-located UX design stages on a distributed team without changing a single thing about how those stages work.

Remote doesn’t break UX design stages. Running them the same way you would in an office does.

The Core Problem: UX Design Stages Were Built for Rooms

Every standard UX design stage – discovery, research, synthesis, wireframing, testing, handoff – was designed around physical proximity. Whiteboards. Hallway conversations. Shoulder taps.

Remove the room and the stages don’t disappear. They slow down, fragment, and produce worse outputs.

The fix isn’t more video calls. It’s redesigning each stage for async-first execution.

Every stage needs a defined output, a defined owner, a defined deadline, and a defined way to give feedback without requiring everyone online at the same time.

Stage 1: Discovery – Replace Workshops With Structured Docs

Discovery workshops collapse async. The classic two-day offsite with sticky notes and dot voting relies on real-time energy and momentum. Remotely, it becomes a three-hour Zoom call where one person dominates a Miro board while everyone else watches.

Replace the workshop with a structured discovery document.

One Google Doc. One owner. Sections for: problem statement, user segments, known pain points, business constraints, success metrics. Everyone adds input asynchronously within 48 hours. Owner synthesises. One 30-minute call to resolve conflicts only – not to generate content.

The rule: discovery produces a written brief, not meeting notes. If it isn’t written down with an owner’s name on it, it doesn’t exist.

Output that closes this stage: a signed-off discovery brief, agreed by PM, lead designer, and engineering lead.

Stage 2: User Research – Time Zones Are an Advantage

Scheduling kills remote research. Three researchers, six participants, four time zones – a calendar puzzle that takes a week to solve before a single interview happens.

Start with async research methods. Save live sessions for edge cases.

Surveys, recorded walkthroughs via Loom, and unmoderated usability tests generate data without scheduling constraints. Participants complete them when it suits them.

Time zones work in your favour. A researcher in Kyiv runs sessions in the morning. London picks up in the afternoon. You cover more participant slots without anyone working unsociable hours.

Output that closes this stage: a research repository – raw findings tagged by theme, accessible to the whole team.

Stage 3: Synthesis – The Stage Most Remote Teams Skip

This is the UX design stage that quietly destroys remote projects. Synthesis – turning raw research into prioritised insights – requires sustained, focused thinking. It’s hard in an office. Remotely, it gets skipped because nobody schedules it and it produces no visible output until it’s done.

Teams jump from research to wireframes with a vague sense of “what users want.” Design decisions become impossible to defend because nobody can trace them back to evidence.

Lead designer owns it. Output: three to five prioritised insights, each linked to specific research evidence. Not twenty findings. Three to five.

Then one async review: team reads the document, leaves comments within 24 hours, designer resolves and locks the insights.

No wireframes start until synthesis is signed off. This is the rule most remote teams resist. It feels slow. It saves weeks.

Output that closes this stage: an insights document reviewed and signed off by the PM.

Stage 4: Wireframing – Design in Public

The invisible design problem. In an office, design happens visibly – someone sees a sketch on a monitor, asks a question, catches a wrong assumption early. Remotely, designers work in isolation, share when “ready,” and discover misalignments late.

Share a Figma link on day one – before anything looks polished.

Update it daily. Drop a short walkthrough video every two days explaining current thinking and open questions. Invite comments directly in Figma.

One rule for feedback: all wireframe comments go in Figma. Not Slack. Not email. One place, one thread per screen.

This is also where you identify the one MVP flow that must work completely before anything else gets design attention.

Output that closes this stage: reviewed wireframes in Figma with all comments resolved and engineering feasibility confirmed.

Stage 5: Usability Testing – Run It or Ship Blind

Teams skip testing because it feels optional when the team is fragmented and behind schedule. “We’ll iterate after launch” becomes the default. It’s expensive.

Five participants. Unmoderated. Async.

Set up a prototype in Figma. Write five tasks. Put it in a tool like Maze. Get results in 48 hours without scheduling a single call. This isn’t comprehensive research – it’s enough to catch the obvious failures before they ship.

For complex flows, run two moderated sessions over video. Two sessions catch more than zero sessions.

Output that closes this stage: a testing summary with pass/fail on each task and a short list of required changes only.

Stage 6: Handoff – Specs Are Not Optional

Verbal handoff is the final way remote teams lose weeks. In an office, a designer sits with a developer for 20 minutes and answers questions in real time. Remotely, that becomes a five-day async thread of clarifying questions, each blocked on a reply.

Written specs before the handoff call.

For every component: dimensions, states (default, hover, active, disabled, error, loading), interaction behaviour, copy, edge cases. Written in Figma or a linked doc. Before any developer opens the file.

Then one 30-minute walkthrough call – not to explain the design, but to answer questions the spec didn’t cover.

The test: can a developer implement this screen without asking a single question? If not, the spec isn’t done.

Output that closes this stage: complete component specs. Implementation starts within 48 hours. Any questions in the first week get answered within 24 hours.

For context on whether your team is even ready to run these stages – with an internal team or an outsourced UX designer – that’s a different question worth answering first.

Remote teams don’t fail at UX design stages because remote is harder.

They fail because they run co-located processes on distributed teams and wonder why everything takes twice as long.

Each stage needs a defined output. A single owner. A fixed deadline. An async-first feedback method.

Discovery without a written brief isn’t discovery. Synthesis without a document isn’t synthesis. Handoff without specs isn’t handoff.

We’re strict about this because remote is permanent for most teams now. The process needs to catch up.