Back to all posts
App Design7 min read·October 26, 2026

What Should a Mobile App Design Handoff Include?

TB
ThynkBlox Apps Team
App Engineering

A mobile app design handoff checklist should cover screens, component states, interaction rules, assets, text limits, accessibility and unresolved decisions. For each action, explain what happens before, during and after it, including failure and recovery. The handoff is ready when someone can build and test the agreed behaviour without inventing missing product rules.

What belongs in the handoff?

Use this checklist to review the package before development begins. Each item should point to a concrete design, written rule or explicit decision.

AreaWhat to include
ScopeIncluded journeys, entry points and release boundaries
ScreensApproved layouts with realistic content and clear connections
Component statesDefault, active, loading, disabled, empty, error and success states where relevant
InteractionsTap outcomes, navigation, validation, cancellation and recovery
AssetsExport-ready graphics, icons, fonts and placement guidance
TextFinal labels, messages, input limits and overflow behaviour
AccessibilityReading order, control names, focus behaviour and alternatives to visual cues
Open decisionsThe unanswered question, affected journey and decision needed
Acceptance checksObservable outcomes that show the feature behaves as agreed

Start by confirming the release boundary. If the first version supports booking an appointment but not rescheduling it, the handoff should say so. Our guide to how to scope an app MVP can help settle that boundary before individual screens become commitments.

Which screen and component states need designs?

Review each screen under different conditions. A populated list is only one version of a list screen.

Ask what appears when data is loading, no records exist, a search returns no matches or a request fails. Separate an empty account from an unsuccessful search: the useful next action may differ.

For reusable components, describe only the states that apply. A submit button may need default, pressed, loading and disabled states. A text field may need empty, focused, filled, invalid and read-only states.

Specify the meaning behind each state:

  • When does the loading state begin and end?
  • Why is a control disabled, and how does the user learn why?
  • Does retry preserve the previous input?
  • Can previously loaded content remain visible during refresh?
  • What should appear if only part of the screen fails?

Label deliberately excluded states too. If a journey requires a connection, define the offline message and recovery action instead of leaving offline behaviour unstated.

What should interaction notes explain?

Write notes around user actions. “Tap Continue to open the address screen” is a start; it still leaves validation, waiting and failure unanswered.

For each important action, record:

  • Trigger: what the user taps, types, selects or dismisses.
  • Conditions: what must be true before the action can proceed.
  • Feedback: what appears while the action is being processed.
  • Outcome: what changes when it succeeds.
  • Recovery: what the user can do when it fails.

Also explain back navigation, closing a screen, repeated taps and leaving with unsaved changes. Specify whether a selection persists when the user returns.

Use prototypes to demonstrate movement and sequence, then add written notes for rules the prototype does not express. If a swipe reveals an action, describe its alternative control and what happens after activation.

For animation, state its purpose, start and end conditions, and the expected behaviour when reduced motion is requested.

What does a worked handoff look like?

Consider an illustrative appointment request screen. These are example product decisions, not universal rules.

Entry: The user arrives after choosing a service. The selected service appears above the form.

Input: Name and preferred appointment slot are required. An optional note has an illustrative limit of 300 characters. Show a character counter and explain what happens when the limit is reached.

Submission: Tapping “Request appointment” checks the required fields. Missing information gets a message beside the relevant field, and focus moves to the first error.

Waiting: Once the request starts, the button shows “Sending request” and prevents another submission. Entered information remains visible.

Failure: If sending fails, retain the form and offer “Try again”. If the outcome is uncertain, explain how the app checks whether the request already exists before another attempt.

Success: Show a request summary with the status “Awaiting confirmation”. Do not use “Appointment confirmed” unless confirmation has actually happened.

Exit: Returning from the success screen opens the requests list. Leaving an unsent form asks whether to discard its contents.

This is enough detail to discuss, implement and test the journey without guessing what a successful request means.

Which assets and visual rules should be supplied?

Provide the actual assets intended for the app, with a clear indication of where each belongs.

Include approved icons, illustrations, logos and any fonts needed for the design. State whether an image is decorative or conveys information. For photographs or uploaded images, specify the crop, alignment and fallback when an image is unavailable.

Record shared visual rules such as colours, spacing, typography, borders and corner shapes. Explain which elements reuse the same component and which are intentional exceptions.

Clarify whether an icon changes with state, whether an illustration needs different appearances on light and dark backgrounds, and which assets may be recoloured. Confirm permission to use supplied material before treating it as final. See how to design dark mode for a mobile app for the dark theme specifics.

How should text limits and content behaviour be documented?

Supply final wording for buttons, labels, hints, validation errors, empty states and success messages. Placeholder copy should be clearly marked as unfinished.

For each input, distinguish between a business rule and a layout preference. A short-looking field does not establish an input limit.

Document:

  • Allowed input and any deliberate restrictions.
  • Required and optional fields.
  • Minimum or maximum length, with an agreed reason.
  • Whether spaces are retained, removed or treated as empty.
  • When validation appears and when its message clears.
  • Whether long display text wraps, truncates or opens in full elsewhere.

Use realistic content during review. Try a long name, a lengthy address and a multi-line error. If more languages are planned, include the expected behaviour when translated text needs more room.

Never shorten important instructions solely to preserve a tidy screen. Resolve the layout and wording together.

Which accessibility details need explicit decisions?

Include accessibility behaviour alongside the visual design. Our guide to mobile app accessibility design requirements covers these decisions in more depth.

Specify meaningful names for controls that use icons alone. Describe reading order and where focus should move after opening a dialog, submitting a form or encountering an error.

Explain how selected, invalid and unavailable states are communicated beyond colour. Identify which images need descriptive text and which are decorative.

Review what should happen when text is enlarged: which areas expand, which controls move and how the user reaches content below the visible area. For gestures, provide another way to perform the action.

Include visible focus states where keyboard navigation applies. Treat these details as acceptance criteria to check in the working app; a design note alone does not prove the result is accessible.

How should unresolved decisions be handled?

Keep an explicit decision list instead of hiding uncertainty inside comments.

For each open question, record the affected screen, available options, who needs to decide and whether development can proceed safely.

For example: “If the selected slot becomes unavailable during submission, should the app return to slot selection or offer alternatives?” That question affects both the interface and the booking rules.

Mark assumptions as assumptions. If a decision blocks a journey, settle it before treating that journey as ready. Unrelated, fully specified work can proceed separately.

What are the common handoff mistakes?

Supplying only polished screens. Add failure, empty and waiting behaviour wherever the journey needs it.

Treating a prototype as the complete specification. Write down validation, persistence and recovery rules that clicking through cannot reveal.

Using inconsistent wording. Keep action labels and status names consistent across screens, messages and notifications.

Leaving realistic content until later. Review long text, missing images and incomplete records before approving layouts.

Calling unresolved work complete. Make open decisions visible and identify what they block.

For a small app, this can be a compact set of annotated screens and a short checklist. It does not require a large document. The useful measure is whether the agreed journey is unambiguous.

How do you check that the handoff is ready?

Walk through one complete journey using the designs and notes. At every action, ask what the user sees next, what could prevent progress and how they recover.

Turn the answers into observable checks. “Error handling included” is vague. “A failed submission keeps the entered note and offers retry” is testable.

Carry those checks into development and release review. Our guide to testing an Android app before release covers checking the working app against its intended behaviour.

Frequently asked questions

Does every screen need a separate design for every state?

No. Shared components can reference one agreed state definition. Provide separate screen designs when content, layout or recovery changes enough that a component reference leaves ambiguity.

Can development begin before the entire handoff is complete?

Yes, for journeys whose scope and behaviour are settled. Identify dependencies first, and keep blocked decisions visible so unfinished rules do not become accidental product choices.

Who should approve the handoff?

The product owner should confirm scope, wording and business rules. Design and development should review interaction details and feasibility together. Include whoever will verify the acceptance checks.

What should happen when a design changes during development?

Update the affected design, behaviour notes and acceptance checks together. Make the current decision clear, including any consequence for work already built. For the layout and style decisions to hand over, see planning app layouts for phones and tablets and the minimum design system for a mobile app.

Ready when you are

Planning an app of your own?

Tell us where your project is today. We will help you work out the scope before you commit to a budget.