Skip to content
UI/UX14 min read

Design Handoff: What a Designer Should Deliver Before Developers Start Building

What a UI/UX designer should deliver before development, by project type: a deliverables matrix, a handoff sign-off gate, Figma Dev Mode facts and design QA.

01

What should a designer deliver before development starts?

Before developers start, a designer should deliver approved screens for every template with all their states, responsive rules, components and tokens that map to code, interaction and accessibility notes, real content, exported assets and agreed design QA criteria. What else is needed depends on the project: a CMS content model for a marketing site, a sections and blocks map for a Shopify store, flows and permissions for a SaaS app, and platform conventions for a mobile app. The matrix below sets this out by project type.

Two checks sit before the build. The first is whether the design is ready to build at all: are the core flows decided, tested and specified? That is covered by the ready-to-build checklist in our guide to design depth, and this page does not repeat it. The second, covered here, is whether the handoff itself is complete: files marked, walkthrough held, questions owned and acceptance criteria agreed.

This guide is for founders and product owners paying for design, often with a separate designer and development team, and for designers and developers who want a shared standard.

02

Key takeaways

  • Deliverables differ by project type; use the matrix to check what your project needs.
  • Every screen needs its states, not just the happy path.
  • Responsive behaviour must be written down, not left to three artboards.
  • Run the ready-to-build checklist first, then the handoff sign-off gate.
  • Make sure you own the editable files, libraries and licences at the end.
  • Handoff is a phase: design QA continues until release.
03

Deliverables by project type

This matrix is our working framework, not an industry standard. Read down the column for your project. "Required" means developers will guess without it; "Recommended" means it saves real time or rework; "Optional" means useful only in some cases.

DeliverableMarketing websiteShopify storeSaaS web appMobile app
Sitemap or navigation mapRequiredRequired (menus and collection structure)Recommended (app navigation)Recommended (tab and stack structure)
User flows, including error and alternative pathsRecommended (enquiry or booking)Required (product to cart to checkout, account)RequiredRequired
High-fidelity screens for every templateRequiredRequired (home, collection, product, cart, content pages)RequiredRequired
States matrixRecommended (forms, navigation, search)Required (variants, sold out, empty cart, errors)Required (empty, loading, error, permissions)Required, plus permission prompts, offline and push
Responsive or platform specificationRequiredRequired, mobile firstRequiredRequired (iOS and Android conventions, text scaling)
Component library and tokensRecommendedRecommended (mapped to theme sections and blocks)RequiredRequired
Clickable prototypeOptionalOptionalRecommended for core flowsRecommended for core flows
Copy deck and real contentRequiredRequired (real product data, long titles, many variants)RecommendedRecommended
Content modelRequired (content types and which fields editors can change)Required (sections, blocks and any metafields)OptionalOptional (if content comes from a CMS)
Accessibility annotationsRequiredRequiredRequiredRequired
Analytics event listRecommendedRecommended (ecommerce events)RequiredRequired
Asset pack with licencesRequiredRequiredRequiredRequired (app icons and store assets)
Design QA acceptance criteriaRequiredRequiredRequiredRequired
04

Reading the matrix for your project

Marketing websites fail most often on the content model. If the design does not say which parts editors can change, how long a heading can be, and what happens when an image is missing, the CMS gets built around the launch content and breaks the first time someone edits it.

Shopify stores need the design expressed in Shopify's terms. Map each design block to a theme section or block so merchants can rearrange pages later, and show where product data such as size guides or specifications comes from, whether product fields or metafields. Design product pages with real catalogue data: the longest title, the product with the most variants, and the sold-out state.

SaaS web apps live or die on states and permissions. A dashboard designed only with healthy sample data says nothing about the first-run empty state, a failed import or a user without admin rights.

Mobile apps need platform decisions written down: where iOS and Android differ, what happens when a permission is refused, offline behaviour, and how layouts cope with larger system text. See the mobile app development process for where design fits in the build.

05

What Design Handoff Means

Handoff is the point where design intent becomes implementation work. In practice it's a phase, not a moment: developers should see designs while they're forming, handoff packages the approved decisions, and design review continues until release. When it works, the shipped product matches what was designed and tested. When it doesn't, developers fill gaps with guesses and the product drifts.

Most handoff problems are missing information or late changes, not bad development. Designs often show the ideal state at one screen size, and developers then have to decide what happens with long names, errors, slow networks, empty lists or tablets. Each guess drifts from the intent.

06

Handoff Preparation

Before a handoff meeting, get the file ready.

  • Final designs separated from explorations and old versions
  • Frames named after screens and states, in flow order
  • Designs marked ready for development only when approved
  • User flows linked, including alternative and error paths
  • Components used consistently, with no detached one-offs
  • Real content and edge cases in place of placeholder text
  • Open questions listed rather than hidden
  • Links to related tickets, research and prototypes
07

Components and Tokens

When design components correspond to coded components, developers assemble screens from existing parts instead of reinterpreting pixels. Use the same names and properties in design and code where possible, and call out anything new: a new component, a new variant or a change to an existing one. New components need a full spec of their own, not just an appearance in one screen. See how a design system keeps a fast-moving team consistent.

Tokens turn design decisions into shared named values: colours, type sizes, spacing, radii, shadows and motion durations. When designs use tokens, developers read “space-4” or “text-muted” rather than measuring pixels and guessing which colour a hex value was meant to be. In Figma, variables are commonly used to implement tokens, including modes for themes such as light and dark. If you export tokens to code, the Design Tokens Community Group published the first stable version of its format (2025.10) in October 2025; it is a W3C Community Group specification, not a formal W3C standard.

08

Typography and Spacing

Specify type as named styles (font, size, weight, line height, letter spacing) rather than per-screen values, and define how headings and body text scale across breakpoints. Build spacing from a consistent scale and use auto layout so padding and gaps are explicit. Inconsistent one-off values are a common source of “it looks slightly off” feedback that's hard to fix later.

09

Responsive Behaviour

Three artboards don't describe what happens in between. Specify how layouts reflow: which columns stack, what stays fixed and what stretches, how images crop, what hides or moves into menus, maximum content widths and how tables adapt. Designing with constraints and auto layout makes much of this visible in the file, but the written rules matter. Use the component behaviour spec template in our guide to planning responsive design so each component's behaviour at each width is recorded in one place.

10

States

Every component and screen has more states than the happy path. A simple matrix per component makes gaps obvious.

StateExamples to design
InteractiveDefault, hover, focus, pressed, disabled, selected
DataEmpty, loading, partial, full, overflowing
OutcomeSuccess, warning, error, offline
ContentLong text, missing image, zero, very large numbers, other languages
PermissionView-only, no access, upgrade required
11

Assets and Ownership

Export icons as SVG where possible, images at the sizes and formats needed (or provide source files for a build pipeline), and illustrations with clear naming. Mark which assets are final, and keep icons in the design system rather than scattered across files.

Check ownership at the same time. You should hold the editable source files in a workspace your business controls, the component library, and licences for every font, icon set and stock image used. A view-only link or a folder of PNGs is not a handoff you can build on later.

12

Interaction Specifications

Annotate what can't be seen in a static frame: what triggers each interaction, validation rules and when they run, transitions with timing and easing, what happens on slow responses, truncation rules, keyboard behaviour and focus order, analytics events and the reduced-motion alternative. A short prototype shows the feel; written notes remove ambiguity. See microinteractions.

13

Accessibility Annotations

Annotate heading levels, landmarks, focus order, accessible names for icon buttons, alt text, error messaging and live announcements. These are design decisions, and leaving them to developers means they're often missed. See accessibility in UI/UX design for what to annotate.

GitHub reports, from its own internal accessibility audit data, that "nearly half of accessibility audit issues (48%) could have been prevented if design intent had been better documented". That is one company's data, not an industry figure, but it matches the logic: an unannotated design leaves accessibility to chance. GitHub has also published its annotation stamps as a free, open-source Figma library.

14

Figma Dev Mode: what developers need

In Figma, keep a dedicated ready-for-dev page or use the ready-for-dev status on frames. Dev Mode lets developers inspect layout, spacing, styles and variables, read annotations and measurements, download assets and compare a frame with earlier versions. Keep annotations next to the relevant component rather than in a separate document that goes out of date. See Figma for product design.

FeaturePlans listed by Figma at the time of writing
Dev ModeProfessional, Education, Organization, Government and Enterprise; needs a Full or Dev seat
Ready for dev statusEvery plan that includes Dev Mode
Completed statusOrganization and Enterprise only
Code Connect (shows your design system's real code snippets)Professional, Organization and Enterprise

Worth noting

Figma's Dev Mode guide carries no date and Figma changes plans and seat types often. Check the current page before budgeting for developer seats.

15

The Handoff Walkthrough

Walk developers through the flows before they start: the user goal, the happy path, the branches, the new components and the open questions. Record the session. Developers will spot missing states and technical constraints far faster in conversation than by reading a file alone. Answer these questions before they're asked.

  • What happens when this request fails or is slow?
  • What if the text is twice as long, or empty?
  • What does this look like between the designed breakpoints?
  • What does a user without permission see?
  • Which existing component should this use?
  • Is this interaction essential, or can it be simplified?
  • What's the keyboard and screen reader behaviour?
  • Where do these numbers and data come from?
16

The handoff sign-off gate

Use this gate after the design has passed the ready-to-build checklist. That checklist asks whether the design is decided; this gate asks whether the handover is complete. The designer, the lead developer and the product owner each confirm every line. Any "no" either gets fixed or is written down as an accepted risk with an owner.

  • Ready-to-build checklist passed for the scope of the first sprint or release
  • Final frames separated from work in progress and marked ready for development
  • Every deliverable marked Required for this project type in the matrix is present
  • Walkthrough held with the developers who will build it, recorded, and questions logged
  • Every open question has an owner and a date, and none blocks the first sprint
  • New components and variants listed, each with its own specification
  • Design QA acceptance criteria agreed: devices to review on, what counts as a defect, severity levels
  • Change process agreed for approved designs after handoff
  • Editable source files, libraries and licences held in a workspace the business controls

Worth noting

Teams often call a gate like this a "definition of ready". The Scrum Guide does not define one; it says only that items which can be done within one sprint are "deemed ready for selection in a Sprint Planning event". Treat any definition of ready as a team agreement and keep it short.

17

Hypothetical example: a Shopify redesign with a separate designer and developer

Hypothetical example: a founder hires a freelance designer for a Shopify store redesign and a separate agency to build it. The Figma file looks finished. Run against the Shopify column of the matrix, it fails on three lines: product pages are designed only with a short title and two variants, there is no sold-out or empty-cart state, and nothing maps the page designs to theme sections, so the agency cannot tell what merchants should be able to rearrange.

The gate also fails on ownership: the file sits in the designer's personal workspace. None of this is unusual or anyone's fault, but each gap would have become a developer's guess or a change request. Fixing them before the build starts is a short, contained piece of design work; fixing them during the build means rework and a debate about scope.

18

Design QA and Implementation Review

Review builds on real devices against the approved designs: layout, spacing, typography, states, responsive behaviour, interactions and accessibility. Log differences as issues with screenshots, the expected result and a severity, so developers can tell a broken flow from a two-pixel offset. Small, frequent reviews during development work better than one large review before release.

Beyond visual QA, check that the build behaves as designed: validation, error handling, loading, permissions and analytics events. Test with real data and slow networks. Where the build and design legitimately diverge because of a technical constraint, update the design so the file reflects what shipped.

19

Versioning and Change Control

Designs change after handoff; the problem is silent change. Name versions at milestones, keep approved designs separate from work in progress, and when something changes, communicate what changed, why and which tickets it affects. Figma's version history and change comparison help, and branching (on Figma's Organization and Enterprise plans) lets designers work on changes without editing the approved file.

20

Common Handoff Problems

ProblemFix
Only the happy path designedState matrix per component and screen
No responsive specificationAuto layout, constraints and written reflow rules
One-off stylesTokens and design system components only
No content model for the CMS or themeContent types, editable fields and limits defined before build
Specs in documents that go staleAnnotations beside components in the design file
Late, silent design changesVersioning and explicit change notes
No designer involvement during buildScheduled design QA and a shared channel
Files owned by the designer, not the businessTransfer of source files and licences written into the contract
21

When this level of handoff is more than you need

The full matrix suits projects where design and development are done by different people or companies, or where a fixed quote depends on the design. It is more than you need when one person designs and builds a small site, or when a product team works in short cycles with designers and developers side by side; there, run the gate per feature rather than once for the whole project, and keep it to the few lines that matter.

The matrix also has limits. It cannot make an untested design right, and it does not replace developers' own estimates. If the core flows are still undecided, go back to how much design you need before development first. If your design delivery is part of a wider engagement, our UI/UX design service page explains how we approach it.

22

Sources

Figma Help Center: Guide to Dev Mode (vendor documentation; undated); GitHub blog: GitHub's open-source Annotation Toolkit (18 November 2025) (vendor data); The 2020 Scrum Guide; W3C Design Tokens Community Group: specification reaches first stable version (28 October 2025).

Accessed 15 October 2026. Figma's plans, seats and features change; check the current pages before relying on them.

23

Conclusion

A complete handoff is specific to the project: find your column in the matrix, make sure every Required item exists, and run the sign-off gate once the design has passed the ready-to-build checklist. Then keep design involved through the build with small, frequent design QA and explicit change control. Your next step is practical: open the file, walk the matrix column for your project type, and list what is missing before anyone writes code.

Want a second opinion on a design file before the build?

ZSpace Labs is a remote-first technology studio that works with clients globally on UI/UX design and website development. If useful, we can review your design file against the matrix and sign-off gate and tell you what is missing before your developers start.

Start a Project
FAQ

Common questions.

The process of transferring design decisions to developers so they can build the product as intended, including specifications, assets, component details, states and behaviour. It works best as ongoing collaboration rather than a single transfer.

Final screens with all states, responsive behaviour, component specifications, design tokens, typography and spacing, interaction and animation notes, accessibility annotations, assets, real content examples and edge cases. What else is required depends on the project: a marketing site needs a CMS content model, a Shopify store needs a map of theme sections and blocks, and a mobile app needs platform conventions and OS-level states.

Named values for design decisions such as colours, typography, spacing and radii, shared between design and code so both use the same source of truth.

Reviewing the implemented product against the design before release, checking layout, states, behaviour and accessibility, and logging differences to fix.

Separate final designs from explorations, mark frames ready for development, build with components and variables that map to code, annotate behaviour, and walk developers through the flows. Figma's Dev Mode supports inspection, annotations and change comparison. At the time of writing, Figma lists it on the Professional, Education, Organization, Government and Enterprise plans, for people with a Full or Dev seat.

Yes. Involving developers during exploration catches feasibility issues early and makes handoff a continuation rather than a surprise.

Common causes are missing states, undefined responsive behaviour, one-off styles outside the design system, unclear specs, late design changes and no design review during development.

Version approved designs, communicate changes explicitly with what changed and why, update the related tickets, and avoid silently editing frames developers are already building from.

What happens on error, with long or missing content, on slow networks, between breakpoints, for users without permission, and which existing components to reuse.

Design tools with inspect or developer modes, shared component libraries, token pipelines, component workshops such as Storybook and issue trackers. The practices matter more than the specific tools.

No. The Scrum Guide does not define one. It says only that items which can be done within one sprint are deemed ready for selection in Sprint Planning. A definition of ready is a convention many teams adopt, so agree your own version rather than treating it as a fixed standard.

The editable source files (not just exports or a view link), the component library and any token files, the prototype, and licences for the fonts, icons and stock imagery used. Confirm in the contract that these transfer to you, and that files sit in a workspace your business controls.

Get in touch

Have a project in mind?

Whether you're building a new digital product, improving an existing website, or looking to automate part of your business — let's talk.