Design & Development← All articles
Figma to Development Handoff: A 2026 Checklist for Designers and Agencies
A great design can still turn into a slow, expensive build if the developer has to guess. Here is what to prepare in Figma before handoff, so the site launches on time and looks the way you designed it.
/led by Dmytro Hrachov
Short answer:
Before handing a Figma design to development, prepare the mobile and desktop layouts, every interactive state (hover, focus, error, loading, empty), motion references, real content, exported assets with web-licensed fonts, and a short list of launch requirements. These answer the questions a developer would otherwise guess at, which is where most delays and extra costs come from.
Key takeaways
- Most rework in a build comes from questions the design didn't answer, not from code.
- Google indexes the mobile version of every site, so the mobile layout is not optional.
- Interactive states, motion and real content matter as much as the static screens.
- Accessibility basics (contrast, focus, tap targets) are easier to fix in Figma than in code.
- A 30-minute design review with the developer before the build saves days later.
Why handoff decides budget and timeline
A developer estimates what they can see. When a screen is missing, a button has no hover state or the text in the mockup is shorter than the real copy, someone has to decide how it should work. Either the developer guesses and the designer asks for changes later, or the work stops while everyone waits for answers.
Both cost time and money. A clear handoff turns those open questions into decisions before development starts, so the estimate is accurate and the result matches the design.
1. Layouts for every screen size
Since July 2024, Google crawls and indexes all websites with its smartphone crawler. If content or a feature exists only on desktop, Google may not see it at all. Mobile is not a scaled-down version of the site; it is the version search engines judge you by.
Prepare:
- Mobile (around 375 px) and desktop (1440 px) for every page template.
- Tablet only where the layout actually changes, for example a menu or a grid.
- Notes on what happens between breakpoints: what stacks, what hides, what scrolls.
2. Interactive states
Static screens show the happy path. Real users click, wait, make mistakes and land on empty pages.
Prepare:
- Buttons and links: default, hover, focus, active, disabled.
- Forms: empty, filled, error with message, success, sending.
- Data: loading, empty state ("No projects yet"), error state.
- Navigation: open and closed mobile menu, current page.
The focus state is often forgotten. It shows keyboard users where they are on the page, and it is required for accessibility.
3. Motion
"Smooth animation on scroll" means something different to every person. A short reference removes the guesswork.
Prepare:
- A video or prototype for every non-trivial animation: what triggers it, how long it takes, how it eases.
- What should happen on mobile, where hover doesn't exist and performance is lower.
- A reduced-motion version. Browsers let users ask for less motion (the prefers-reduced-motion setting), and the site should respect it.
4. Components and styles
A consistent Figma file becomes a consistent codebase.
Prepare:
- Colours, type and spacing as Figma variables or styles, not one-off values.
- Repeating elements as components with variants (button sizes, card types).
- Auto layout where the element should stretch or wrap.
- Clear layer and page names, and a page that marks what is final and what is a draft.
5. Real content
Lorem ipsum hides problems. A headline that fits in the mockup can break the layout when the real one is twice as long, or when the site launches in a second language.
Prepare:
- Real or realistic text for every block, including the longest expected title.
- All language versions, or at least the longest one.
- One H1 per page marked in the design, and the heading order below it.
- Page titles and meta descriptions, or a note on who will write them.
6. Assets and fonts
Prepare:
- Icons and logos as SVG.
- Photos and illustrations in the highest available quality; the developer will compress and convert them.
- Videos with a poster frame.
- Fonts with a licence that covers web use. A desktop licence often doesn't include embedding the font on a website.
7. Accessibility basics
Accessibility is cheaper to design than to retrofit, and for many businesses selling to EU customers it is now a legal requirement: the European Accessibility Act has applied since 28 June 2025.
Check in Figma:
- Text contrast of at least 4.5:1, or 3:1 for large text (WCAG level AA).
- Tap targets of at least 24×24 px, or enough space around smaller ones (WCAG 2.2, criterion 2.5.8).
- A visible focus state for every interactive element.
- Meaning that doesn't depend on colour alone, for example errors with an icon and a message, not just red text.
8. Performance-aware design
Google measures how fast real visitors experience a page with Core Web Vitals. A page passes when the main content loads within 2.5 seconds (LCP), the page reacts to taps within 200 milliseconds (INP), and the layout shifts less than 0.1 (CLS).
Design decisions affect all three:
- A heavy autoplay video or large 3D scene in the first screen slows down LCP, especially on mobile.
- Many font families and weights add load time. Two families with a few weights is usually enough.
- Elements that appear late (banners, cookie bars, embedded widgets) push content down and hurt CLS unless their space is reserved.
This doesn't mean avoiding motion or 3D. It means deciding where they matter most and agreeing on a lighter version for mobile.
9. Launch requirements
Prepare a short list:
- Who will edit what after launch, and how often. This decides the CMS.
- Where form submissions go (email, CRM, Slack) and who replies.
- Integrations: payments, booking, newsletter, analytics.
- Domain, hosting access and the launch date, including any fixed deadline.
The full handoff checklist
| Area | Ready when |
|---|---|
| Layouts | Mobile and desktop for every template; tablet where the layout changes |
| States | Hover, focus, active, disabled, error, loading, empty, success |
| Motion | Reference video or prototype; mobile and reduced-motion versions |
| Components | Variables for colour, type and spacing; components with variants |
| Content | Real text, longest titles, all languages, one H1 per page |
| Assets | SVG icons, high-quality images, videos with posters, web-licensed fonts |
| Accessibility | Contrast 4.5:1, targets 24×24 px, visible focus, not colour-only |
| Performance | Agreed weight of hero media; light mobile version of heavy effects |
| Launch | CMS editors, form destinations, integrations, domain, deadline |
How we run handoff at ROOKS
We build websites from designers' Figma files every day, for design studios, agencies and businesses. Our process follows the same steps whether the project takes two weeks or thirteen:
- You share the design: layouts, responsive states, motion references and launch requirements.
- We estimate: we define the technical scope, flag risks and estimate the work and timeline.
- We review with your designer: we work through interactions and responsive behaviour together, preserving the design intent.
- We build and test: demos as we go, then real devices and browsers.
- Handover: to you or straight to your client, with a guide.
The review in step 3 is where this checklist pays off. The more of it is ready, the shorter that conversation and the more accurate the estimate.
Frequently asked questions
What should a designer prepare for a developer handoff?
Mobile and desktop layouts for every template, all interactive states, motion references, real content in every language, exported assets, web-licensed fonts and a list of launch requirements. Together, they let the developer estimate accurately and build without guessing.
Do I need to design a tablet version?
Only where the layout changes in a meaningful way, such as navigation or a grid that switches from three columns to two. For most pages, mobile and desktop designs plus notes on how elements adapt in between are enough.
Can a developer work from an unfinished design?
Yes, if it's clear which parts are final. Mark draft pages in Figma, start with the templates that won't change, and review the rest with the developer before it goes into development.
Does Figma Dev Mode replace a handoff?
No. Dev Mode gives developers accurate measurements, styles and assets, but it can't explain how something should behave, what happens on error or what the content will be. Those decisions still need to be in the design or the handoff notes.
Sources
- Google Search Central: Mobile-indexing vLast final final (June 2024) (opens in a new tab)
- web.dev: Web Vitals (opens in a new tab)
- web.dev: Interaction to Next Paint becomes a Core Web Vital on March 12 (opens in a new tab)
- W3C: Understanding Success Criterion 2.5.8 Target Size (Minimum) (opens in a new tab)
- W3C: Understanding Success Criterion 1.4.3 Contrast (Minimum) (opens in a new tab)
- European Commission: European Accessibility Act (opens in a new tab)

