Tithi Mondal

Guide6 min readUpdated

Figma Developer Handoff Checklist for Founders

A Figma developer handoff checklist you can use to check what your designer sent: files, specs, assets, states and notes, in plain language.

By Tithi Mondal, UI/UX Designer

What design handoff actually means

Design handoff is the moment the design stops being a set of pictures and becomes instructions that a developer can build from. It is where many projects quietly lose time. The design looks finished, but the developer has to ask forty questions, guess the answers, or build something different from what you approved.

You do not need to read code to check a handoff. You need to know what should be in the package. This checklist is written for founders and product people who want to check what they received, whether the design was made by me or by anyone else.

The short version: the developer should be able to open one link, find every screen, see how each one behaves, and download every asset without messaging the designer.

Before you start: the Figma file itself

Open the file and check these first.

  • One file, one link. All final screens live in one Figma file, shared with your developer with the right access. View access is enough for most developers.
  • Clear pages. A page for final screens, a page for components, and old explorations kept separate so nobody builds from an outdated version.
  • Ready markers. Screens that are approved for development are marked as ready. Figma has a status you can set on sections for this, so the developer sees at a glance what is final.
  • Sensible names. Screens are named by what they are, for example "Cart / Empty" or "Order tracking", not "Frame 214".
  • Right frame sizes. Mobile screens at real device sizes, plus a smaller phone size if your users have budget Android devices.

Checklist: screens and states

This is where most gaps hide. A single screen is rarely a single screen.

  1. Every screen in the flow is there, including the boring ones: login, forgot password, settings, logout confirmation.
  2. Empty states. What does a list show before there is any data? A new seller with zero orders needs a designed screen, not a blank one.
  3. Loading states. What shows while data comes in? This matters in places with slow connections.
  4. Error states. Wrong OTP, no internet, payment failed, server error. Each needs words and a next step.
  5. Success states. After placing an order or submitting a form, what does the user see?
  6. Long and short content. What if a name is very long, or a price has many digits? What does a regional language label do to the layout?
  7. Different user roles. If your product has a buyer, a seller and an admin, each role's screens are included.

Checklist: components, colours and type

Good handoff makes the developer's work reusable, not just one-off.

  • Buttons, inputs, cards and other repeated parts are built as Figma components, not copied boxes.
  • Each component shows its states: default, pressed, disabled, error.
  • Colours and text styles are saved as named styles, so the developer sees "primary" and "heading 2", not just random values. If you have a design system, this is where it pays off.
  • Spacing follows a consistent rule, for example multiples of 8, and the rule is stated.
  • Fonts are named, with the source or licence noted, so the developer can install or load the right ones.

Checklist: Figma Dev Mode and specs

Figma has a Dev Mode view made for developers. In it, a developer can select an element and read its size, spacing, colour and text details, and copy values. It is available on paid Figma plans, so check with your designer which plan the file is on.

Things to check:

  • The developer can open the file in Dev Mode and read measurements without asking.
  • Layout uses auto layout where possible, so spacing rules are clear and screens adapt when text changes length.
  • Important behaviour is noted next to the screen, because Dev Mode shows how things look, not how they should act.

Do not worry if the developer does not use every feature. What matters is that the information exists somewhere they can find.

Checklist: assets and exports

Assets are the images and icons that go into the build.

  • Icons exported as SVG, so they stay sharp at any size.
  • Photos and illustrations exported in the formats and sizes the developer asks for, with sensible file sizes so the app stays light for users on mobile data.
  • App icon and splash screen prepared in the sizes each store requires.
  • Logo files in vector format with a transparent background.
  • File names are clear and consistent, for example "icon-cart.svg", not "Group 12.svg".
  • A short list of which asset belongs on which screen, if it is not obvious.

Checklist: notes the screens cannot show

A picture cannot say what happens when you tap, wait or fail. Look for written notes covering:

  1. What each button does and where it leads.
  2. Validation rules: required fields, allowed characters, phone number format.
  3. How lists behave: sorting, filters, pagination or infinite scroll.
  4. What happens offline or on a weak signal.
  5. Any animation or transition that matters.
  6. Differences between roles, such as what an admin can edit that a user cannot.

A clickable prototype also helps a great deal here. Walking through the flow on a phone answers many questions faster than text. The difference between a wireframe, a mockup and a prototype is covered in wireframe vs mockup vs prototype.

Checklist: people and process

The files are only half of the handoff.

  • A named person answers developer questions for an agreed period after delivery. Ask your designer how long.
  • Questions go in one place, such as a shared WhatsApp group or a comment thread in Figma, not scattered across five chats.
  • There is a plan for changes. When something is updated after handoff, the developer is told which screens changed.
  • You know what is in scope. New screens requested later may be a new quote.

On the app and web projects I design, the final stage of my process is prototype and hand off, and I stay available for developer questions. My terms include two to three revision rounds, but I recommend finishing all changes before handoff, because changing screens during development is where confusion starts.

How to run this check in 20 minutes

  1. Open the Figma file and the prototype link on your phone.
  2. Walk the main journey once as a customer, then once as a seller or admin if you have those roles.
  3. For each screen, ask: what if there is no data, what if it fails?
  4. Ask your developer to open Dev Mode and try to find one colour and one spacing value.
  5. Ask them to download three assets without help.
  6. Send any gaps back to the designer as one list, not many messages.

If your developer says they can start without questions, the handoff is good. If you have just finished a project and are unsure about the next step, the mobile app design process shows how handoff fits at the end. And if you would like a design delivered in this kind of ready state, you can read about my mobile app design service or write to me through the contact section.

Frequently asked questions

What should a designer give a developer?

The final Figma file with all screens and states, reusable components, named colour and text styles, exported assets such as SVG icons, written notes on behaviour, and a way to ask questions.

Does my developer need a paid Figma account?

Not necessarily. Developers can view files and export assets with view access. Dev Mode is a paid feature, so ask your designer which plan the file is on.

When does design handoff happen?

After all revisions are approved and the screens are final. Handing off while changes are still coming causes rework for the developer.

What if the developer finds missing screens during the build?

This is common when empty, error or loading states were not designed. Send the list to your designer together, so the missing screens can be completed in one batch.

Have a product in mind? Let us design it properly.

Tell me what you are building. I will reply with questions, a rough timeline and a quote.