Skip to main content
All articles
  • Other

Updated 8 min read

What should a startup’s design handoff to developers include?

Hand developers every screen state, the layout rules, tokens, final copy, accessibility notes and analytics events, plus one person who answers questions during the build.

A startup’s design handoff should give developers every state of every screen, the layout rules between widths, the tokens and components the screens use, the final copy, the accessibility notes, the analytics events and a named person who answers questions during the build. A handoff that is only a link to finished screens leaves developers to invent the empty states, the errors and the edge cases, and that is where most rework starts. Humbleteam designs startup products from wireframes to launch for clients including Afternoon, where activation rose 32% after the app redesign, Logitech, whose design system, mobile app and website went from a blank state to production in 4 weeks, and Synthesia.

Humbleteam, a digital product design agency, publishes this guide. It covers what a design handoff package contains, a checklist with a “done when” test for each item, an invented worked example for a signup flow and the questions to settle before the first sprint. Sources are described as of November 15, 2026.

Why does the handoff decide how much gets rebuilt?

Design files show the screen a designer had in mind. Developers build the screen the product will actually meet: a slow network, a name with 60 characters, a user without permission, a list with zero items. When the file does not say what happens in those cases, the developer decides, the designer sees it in review, and the work goes round again.

More screens will not solve this. What helps is a package that answers the questions a developer would otherwise ask in the middle of a sprint. Tools help with part of it. In Figma’s Dev Mode, designers can mark frames, components and sections as ready for development, add annotations with specs and measurements, and developers can compare frame versions to see what changed. Those features carry the package. They do not decide what goes into it.

What belongs in the handoff package?

Ten items cover most startup features. Each one has a simple test: if the developer can build that part without asking, the item is done.

Design handoff checklist, with a “done when” test for each item (our working list)
ItemWhat it containsDone when
Scope and statusWhich frames are ready, which are still in progress, and the ticket each one belongs toEvery frame in the sprint is marked ready, and nothing in progress sits next to it unlabeled
Screen statesDefault, empty, loading, error, partial data, long content, no permission, successEach screen in scope shows every state that can occur, or a note says why one cannot
Layout behaviorWhat stretches, wraps, stacks or hides between the smallest and largest supported widthsA developer can predict the layout at any width between the frames shown
Tokens and componentsColor, type, spacing, radius and shadow values as named tokens; the components used and their variantsNo screen uses a raw value that is not a token, or the exception is noted
Interaction and motionWhat each control does on tap, hover, focus and keyboard; transition timing where it mattersEvery interactive element has a described result, including the disabled state
CopyFinal text, including errors, empty states, buttons, emails and push messages, in one source of truthNo placeholder text is left, and the copy source says which version is final
Accessibility notesFocus order, labels for icon buttons and form fields, contrast checks, target sizesThe notes cover each new component, and contrast and target size are checked
Analytics eventsEvent names, when each fires and its properties, tied to the launch metricThe product owner signs off the event list before build starts
AssetsIcons, illustrations and images exported at the right formats and sizesDevelopers never take a screenshot to get an asset
Questions log and ownerA shared list of open questions, decisions and the person who answers themEach open question has an owner and a date

How detailed should the screen states be?

Detailed enough that nothing is guessed. A list screen, for example, needs at least five versions: the first time it is empty, the loading state, a normal list, a list after a filter returns nothing and an error when the data fails to load. A form needs the empty form, inline validation errors, a server error and the submitted state.

Write the trigger next to each state. “Shown when the account has no projects yet” tells a developer when to render it. “Empty state” on its own does not.

Which accessibility notes belong in the handoff?

The notes that a developer cannot see in a static frame. Three of the W3C’s Web Content Accessibility Guidelines are worth checking at handoff because they are easy to miss in a mockup:

  • Focus order: when people move through a page with the keyboard, focus should follow an order that keeps meaning and operation intact. Number the focus order on complex screens such as forms and modals.
  • Contrast: text should have a contrast ratio of at least 4.5:1, with 3:1 allowed for large text. Check gray helper text and disabled buttons, where contrast usually fails.
  • Target size: pointer targets should be at least 24 by 24 CSS pixels, with exceptions for spacing. Small icon buttons in tables and toolbars are the usual problem.

Add a label for every icon-only button and every form field. A developer can build a visible label from a frame. A label that only a screen reader will announce has to be written down.

How should tokens and components be handed over?

As names, not numbers. When a button uses “color/action/primary” rather than a hex value, a later color change touches one token instead of every screen. The W3C Design Tokens Community Group publishes a format for exchanging tokens between tools, in which each token carries a value and a type such as color or shadow. A startup does not need the full format on day one, but it should pick one naming scheme and use it in both the design file and the code.

For components, the handoff should say which existing component each element uses and which variant. A new component needs its own sheet: all states, sizes and the rules for when to use it.

What does a handoff look like for one feature?

The example below is invented to show the shape. An illustrative B2B startup is shipping an email signup with workspace creation.

Invented example, handoff notes for a signup flow
ItemNotes in the handoff
Scope4 frames ready: email entry, verify code, create workspace, invite teammates. Invite teammates can be skipped.
StatesEmail entry: empty, invalid email, email already registered (link to sign in), rate limit after 5 tries, loading. Verify code: wrong code, expired code, resend timer. Workspace: name taken, name too long (40 characters), server error.
LayoutSingle column; card width fixed on desktop, full width with 16 px side padding below 480 px.
TokensAll colors and spacing from the existing token set; one new token for the code input border on error.
InteractionCode field accepts paste of the full code; focus moves to the next digit automatically; Enter submits.
CopyFinal copy for 11 error messages and the verification email in the shared copy document, version marked final.
AccessibilityFocus order numbered on all 4 frames; code digits announced as “Digit 1 of 6”; error messages linked to their field.
Analyticssignup_started, email_submitted, code_verified, workspace_created, invite_sent, invite_skipped, each with source and timestamp.
OwnerThe product designer answers questions in the sprint channel within one working day.

Most of the example is states and copy, which is exactly the part a frame of the main screen leaves out.

Who should own the handoff on the agency side and on yours?

Two people, one on each side. The design owner keeps the package current and answers questions. The engineering owner reads the package before sprint planning and turns open questions into the questions log, so they are answered before code is written rather than during it.

If the design team is external, write this into the working agreement: when the package is due before each sprint, how fast questions get answered and who approves a change after build starts. Our guide to what an end-to-end design agency should own from wireframes to launch covers the rest of that scope.

What happens after developers build it?

The handoff sets the standard that the built product is checked against. Before launch, a designer should review the build against the same states, widths and copy listed in the package, and rank every difference by severity. Our guide to running design QA before launch sets out that review step by step.

What can you produce now?

  1. The ten-item checklist above as a template in your design file or ticket system.
  2. A state inventory for your next feature: every screen, every state, and the trigger for each.
  3. A token naming scheme, even a short one, shared by design and code.
  4. An analytics event list for the feature, signed off before build.
  5. A questions log with an owner and a response time.

Let's talk

Have questions? Ask AI
Opens a new chat with context about us pre-loaded — ask anything

We’ll reply within 24 hours with case studies, a timeline, and an estimate.

Prefer email? Write to hi@humbleteam.com
All set – our team’s on it. Expect a reply soon.
Send another one
Oops! Something went wrong while submitting the form.
Have questions? Ask AI
Opens a new chat with context about us pre-loaded — ask anything
Europe
Národní 135/14, Prague
Middle East
UAE, Dubai, Internet City Offices
We use cookies to enhance your browsing experience, serve personalized ads or content, and analyze our traffic. By clicking “Sounds good!” you consent to our use of cookies.
Privacy policy