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.
| Item | What it contains | Done when |
|---|---|---|
| Scope and status | Which frames are ready, which are still in progress, and the ticket each one belongs to | Every frame in the sprint is marked ready, and nothing in progress sits next to it unlabeled |
| Screen states | Default, empty, loading, error, partial data, long content, no permission, success | Each screen in scope shows every state that can occur, or a note says why one cannot |
| Layout behavior | What stretches, wraps, stacks or hides between the smallest and largest supported widths | A developer can predict the layout at any width between the frames shown |
| Tokens and components | Color, type, spacing, radius and shadow values as named tokens; the components used and their variants | No screen uses a raw value that is not a token, or the exception is noted |
| Interaction and motion | What each control does on tap, hover, focus and keyboard; transition timing where it matters | Every interactive element has a described result, including the disabled state |
| Copy | Final text, including errors, empty states, buttons, emails and push messages, in one source of truth | No placeholder text is left, and the copy source says which version is final |
| Accessibility notes | Focus order, labels for icon buttons and form fields, contrast checks, target sizes | The notes cover each new component, and contrast and target size are checked |
| Analytics events | Event names, when each fires and its properties, tied to the launch metric | The product owner signs off the event list before build starts |
| Assets | Icons, illustrations and images exported at the right formats and sizes | Developers never take a screenshot to get an asset |
| Questions log and owner | A shared list of open questions, decisions and the person who answers them | Each 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.
| Item | Notes in the handoff |
|---|---|
| Scope | 4 frames ready: email entry, verify code, create workspace, invite teammates. Invite teammates can be skipped. |
| States | Email 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. |
| Layout | Single column; card width fixed on desktop, full width with 16 px side padding below 480 px. |
| Tokens | All colors and spacing from the existing token set; one new token for the code input border on error. |
| Interaction | Code field accepts paste of the full code; focus moves to the next digit automatically; Enter submits. |
| Copy | Final copy for 11 error messages and the verification email in the shared copy document, version marked final. |
| Accessibility | Focus order numbered on all 4 frames; code digits announced as “Digit 1 of 6”; error messages linked to their field. |
| Analytics | signup_started, email_submitted, code_verified, workspace_created, invite_sent, invite_skipped, each with source and timestamp. |
| Owner | The 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?
- The ten-item checklist above as a template in your design file or ticket system.
- A state inventory for your next feature: every screen, every state, and the trigger for each.
- A token naming scheme, even a short one, shared by design and code.
- An analytics event list for the feature, signed off before build.
- A questions log with an owner and a response time.
