Designers6 min

Developer handoff that doesn't break: a Dev Mode checklist

A practical Figma Dev Mode developer handoff checklist covering components, tokens, states, specs and annotations so designs ship the way you intended.

Saurabh YadavFounder, Design Studio by Saurabh
DesignersDesign handoff Figma
Share

Handoff is where good design quietly turns into something slightly worse. A spacing value gets eyeballed, an empty state never gets built, a button ships without its disabled style, and three sprints later the product looks almost like the design, but not quite.

Most of the time this isn't the developer's fault. It is a gap in what the design file actually communicates. Figma Dev Mode makes inspecting a file much easier, but it can only show what you put there.

At Ksolves I prepare developer handoff in Dev Mode within Agile sprints, and this is the checklist I work through before I mark anything ready for development.

Treat handoff as a process, not a moment

The biggest shift is to stop thinking of handoff as the day you send a link. It works better as a habit that runs through the whole project:

  • Early: involve a developer in flows and wireframes so technical constraints show up before the UI is polished.
  • During design: build with real components and tokens so the file mirrors how the code will be structured.
  • At handoff: walk through the file together rather than dropping it in a channel.
  • After: review the build against the design and fix gaps quickly.

A file that was built carefully barely needs explaining. A messy one needs a meeting for every screen.

Stage What I do What breaks if you skip it
Early Share flows and wireframes with a developer Constraints surface after the UI is polished
During design Build with components, variants and tokens Developers guess which greens and gaps are the same
At handoff Walk through the file together Questions pile up in chat, answers get lost
After the build Review on a real device, log gaps with screenshots Small drifts become the new normal

Prepare the file

Organise pages and frames

  • Separate work-in-progress from ready-for-dev. A dedicated page or clear section labels avoid developers building an old exploration.
  • Name frames meaningfully: "Transfer / Review" is more useful than "Frame 2381".
  • Group screens by flow so the order reflects the user journey.
  • Use Dev Mode's "ready for dev" status so developers know exactly what is final.

Clean up layers

  • Remove hidden layers, detached experiments and stray elements.
  • Use Auto Layout for anything that should resize. It communicates padding and spacing far better than absolute positions.
  • Name important layers so the inspect panel is readable.

Use components and tokens properly

Components with variants

Every reusable element should be a component, with variants for its states. A button isn't one thing; it is default, hover, pressed, focused, disabled and loading. If those variants don't exist in the file, they probably won't exist in the build.

On Demerara Bank, the mobile app (38 screens) and the web banking revamp (24 screens) were built on one shared design system. That only works if components and variants are consistent enough for developers to map them to code once and reuse them everywhere.

Colour and type as styles or variables

Never hand off raw hex values scattered across screens. Define colours and type as styles or variables, with names that mean something. Demerara's palette, for example, had clear roles: Demerara Green as the primary, Growth Green and Heritage Gold as supporting colours. Developers can map named tokens to code once instead of guessing whether two greens are meant to be the same.

Spacing on a scale

Tip

Keep a short "changelog" note on the ready-for-dev page. When a screen changes after handoff, a dated one-liner saves a developer from comparing two versions pixel by pixel.

Use a consistent spacing scale and stick to it. If a gap is 13px in one place and 16px in another for no reason, a developer will either copy the inconsistency or "fix" it in a way you didn't intend.

For more on keeping this manageable, read design systems for small teams.

Design every state, not just the happy path

This is where most handoffs break. For each screen, check:

  • Empty states: no data yet, first-time use.
  • Loading states: skeletons, spinners or progress.
  • Error states: failed network, invalid input, server errors, with helpful copy.
  • Edge cases: long names, large numbers, missing images, small screens.
  • Success and confirmation: what the user sees when a task completes.
  • Permissions: what changes for different roles.

On a banking transfer flow, for example, the form, review and success screens are only the start. What happens if the transfer fails? If the balance is too low? If the session times out halfway? Each of those needs a designed answer.

Watch out

A missing state doesn't stay missing. A developer under sprint pressure will fill the gap with something quick, and that quick version often ships. Designing the error screen yourself is cheaper than fixing it later.

Annotate what Dev Mode can't infer

Dev Mode shows measurements, but it can't show intent. Add annotations for:

  • Behaviour: what happens on tap, swipe or long press.
  • Logic: conditions for showing or hiding elements.
  • Motion: duration, easing and what triggers a transition. My motion background makes me careful here: a transition described as "smooth" will be built ten different ways.
  • Responsive rules: what stretches, what wraps and what stacks at different widths.
  • Accessibility: focus order, labels for icon buttons, minimum tap target sizes and contrast requirements. The WCAG guidelines are the reference here, and I cover the basics in accessibility is UX.
  • Content: which text is final copy and which is placeholder.

From my work

Before UX, I spent over two years at Algoworks animating UI transitions and micro-interactions. The lesson that stuck: write the duration, the easing and the trigger next to the frame, because "make it feel smooth" means something different to everyone.

Prototype the tricky parts

Static screens can't explain everything. For complex interactions, I build a clickable prototype for stakeholder reviews and, where it helps, deploy a live prototype on Vercel so developers and stakeholders can feel the flow on a real device. Seeing an interaction is usually faster than reading a paragraph about it.

Work with us

Want this set up properly? Our design system agency builds Figma libraries, tokens and documentation that scale with your team.

Key takeaways

  • Handoff is a habit across the project, not a single link at the end.
  • Build with components, variants and named tokens so the file mirrors the code.
  • Design every state: empty, loading, error, edge cases and success.
  • Annotate behaviour, motion, responsive rules and accessibility.
  • Walk developers through the file and review the build afterwards.

The final checklist

Before marking a screen ready for dev:

  • Frames are named, ordered by flow and marked ready for dev.
  • Work-in-progress is separated from final designs.
  • All reusable elements are components with full variant sets.
  • Colours, type and spacing use defined styles or variables.
  • Auto Layout is used wherever things should resize.
  • Empty, loading, error, edge and success states are designed.
  • Interactions and motion are annotated with timing and triggers.
  • Accessibility notes are included: focus order, labels, tap targets, contrast.
  • Responsive behaviour is described or shown.
  • Copy is final or clearly marked as placeholder.
  • Assets that need exporting are marked for export.
  • You have walked a developer through it and answered their questions.

After the build: close the loop

Once a feature is built, review it against the design on a real device. Log differences clearly with screenshots, and separate bugs from deliberate trade-offs the developer made for good reasons. A respectful, specific review builds trust, and the next handoff gets easier.

If you want to see what a shared design system across mobile and web looks like in practice, read the Demerara Bank case study. For questions about my handoff process, ask Sage or email me.

Saurabh Yadav's Memoji

Written by

Saurabh Yadav

Founder of Design Studio by Saurabh, a UI/UX design studio in India. We design apps and websites that feel effortless, from research to shipped pixels. Most recently: Pukaar.ai, as seen on Shark Tank India, and the Demerara Bank app.

Keep reading

All articles →