Handoff That Saves Time: A Developer‑First Asset Pack Checklist and Example Folder
Written by AppWispr editorial
Return to blogHANDOFF THAT SAVES TIME: A DEVELOPER‑FIRST ASSET PACK CHECKLIST AND EXAMPLE FOLDER
Design-to-development handoffs are predictable friction: missing SVGs, unclear acceptance criteria, ambiguous edge cases, and no API contract. This guide gives founders and product builders an end-to-end, developer-first checklist plus a sample folder structure and a downloadable ZIP recipe so engineers can build features without chasing designers.
Section 1
What a Developer‑First Asset Pack Must Contain
Engineers need three things from a handoff: deterministic assets they can drop in the build, unambiguous implementation rules, and a minimal API contract or mock that defines runtime behavior. Treat the asset pack like a tiny RFC: name, purpose, expected behavior, and failing conditions.
Below is the core checklist. Each entry is written from the engineer’s perspective so designers and product managers know the exact item to produce and why it matters.
- Design file link and version (Figma/Zeplin) + 'Ready for dev' flag and the exact page/frame reference.
- Exported assets: SVG icons (clean IDs, no inline styles), 1x/2x/3x PNGs for raster images, WebP where appropriate, and source SVGs (editable .svg).
- Named components and tokens: color tokens, spacing tokens, type tokens exported in a machine‑readable JSON or design tokens format.
- Annotated acceptance criteria per screen: expected states, edge cases, error texts, and interaction timing (e.g., animation durations).
- Minimal API stubs: example request/response JSONs, end-point URL placeholders, and clear schema for fields used by the UI.
- Build notes: expected CSS classes/JS hooks (if any), recommended responsive breakpoints, and accessibility requirements (aria labels, contrast).
Section 2
How to Annotate Designs and Write Acceptance Criteria
Annotations must be short, explicit, and discoverable inside the design file. Use Dev Mode (Figma) or component notes (Zeplin) for each interactive element. Put acceptance criteria next to the frame (not buried in a long doc). Prefer checklist-style bullets engineers can validate.
Acceptance criteria should include state names (default, hover, pressed, disabled), exact copy, validation rules for inputs, performance expectations (image size budget), and success/failure UI for async flows (e.g., loading skeletons vs spinners).
- Per-component: states + measurable details (e.g., 'button transitions in 120ms linear').
- Per-screen: key flows (happy path + two edge cases) and success criteria (how QA confirms the flow).
- Data requirements: which fields are required, example values, and expected error codes/messages.
- Accessibility: minimum contrast target, keyboard focus order note, and aria-text examples.
Sources used in this section
Section 3
Exact Files to Include (Naming & Formats)
Don’t deliver a vague 'icons' folder—deliver a predictable, named set that maps to code. Use kebab-case for filenames, semantic prefixes, and include a manifest.json at the root that lists each item and its purpose.
Supply both human- and machine-friendly formats: source SVGs and a compiled icons.svg sprite (if your front-end uses sprites), raster fallbacks for legacy targets, and JSON tokens for design variables. Keep file sizes and vector cleanliness in mind: flatten unnecessary groups in SVGs and remove editor metadata.
- icons/ico-user.svg, icons/ico-user@2x.png — icons always as .svg (editable) + PNG fallbacks.
- images/hero-1200w.jpg, images/hero-600w.jpg — responsive raster exports with size in filename.
- tokens/design-tokens.json — colors, typography, spacing in a JSON your engineers can import.
- manifest.json — a short map: {"icons/ico-user.svg":"user avatar icon, used in header"}.
Sources used in this section
Section 4
Sample Folder Structure (copy this into your repo or ZIP)
Below is a concise folder structure you can copy into a project ZIP. Name the ZIP using the feature and version (feature-name-v1.0.zip). Include a README.md at the top with links to the Figma/Zeplin frames, the engineering owner, and required environment notes.
The README is the single source of truth for the handoff—make it a short checklist that the engineer can tick off when they finish implementing the feature.
- feature-name-v1.0/
- ├─ README.md (link to design, owner, short checklist)
- ├─ manifest.json (file map + purpose)
- ├─ figma-link.txt (persistent URL + frame id)
- ├─ assets/
- │ ├─ icons/ (ico-*.svg, ico-*@2x.png) │ ├─ images/ (hero-1200w.jpg, thumb-400w.webp) │ └─ illustrations/ (illustration-cta.svg, illustration-cta.png) ├─ tokens/ (design-tokens.json, tokens.css) ├─ api-stubs/ (getFeature.json, postAction.json, readme.md) └─ acceptance-criteria/ (screen-1.md, screen-2.md, tests.md)
Sources used in this section
Section 5
API Stubs, Mock Data, and How Engineers Validate Acceptance
A minimal API stub includes endpoint path, method, sample request body, sample response body, and HTTP error cases. Put these under api-stubs/ and provide curl examples or a Postman collection. This prevents ‘unknown field’ back-and-forth and lets engineers wire the UI to real-ish data quickly.
Validation is easier when you include small, executable checks: a QA checklist referencing acceptance-criteria files, and a short list of unit/integration tests the engineer should add (e.g., 'renders empty state when items.length == 0').
- api-stubs/get-feature.json — sample 200 response and 404 error example.
- postman_collection.json or curl snippets for each endpoint so front-end devs can hit mocks.
- tests.md — minimal QA checklist and suggested component unit tests (props + states).
- Note the contract owner (backend or frontend) and version the stub (v1.0).
Sources used in this section
FAQ
Common follow-up questions
Do designers need to export every icon at multiple scales?
Optimally, supply every icon as a clean source SVG and add 1x/2x PNG fallbacks only when the app targets platforms that need raster images (legacy mobile or older email clients). SVGs are preferred because they scale and let engineers control fill/stroke via CSS. Still include 2x PNGs for developers who want immediate raster assets.
Should the asset pack live in the design tool or in a ZIP inside the repo?
Both. Keep the canonical assets and annotations in the design tool (Figma/Zeplin) for live updates, and produce a versioned ZIP (feature-name-v1.0.zip) pushed to the repo or a release for engineering to consume. The ZIP is a snapshot engineers can reference in case the design file changes.
How granular should acceptance criteria be?
Be concrete and testable. Each criterion should be a short sentence an engineer or QA can mark as pass/fail (e.g., 'Typing invalid email shows helper text “Enter a valid email” and prevents form submit'). Include state names, example inputs, and where applicable the HTTP error code to display.
Can I automate parts of this handoff?
Yes. Use Dev Mode in Figma to expose measurements and code snippets, use Zeplin or a styleguide to export multiple asset scales, and adopt token export tools (e.g., design-tokens JSON exporters). Automation reduces manual errors but a tiny README and a manifest are still crucial.
Sources
Research used in this article
Each generated article keeps its own linked source list so the underlying reporting is visible and easy to verify.
Figma
Free Design Handoff Tool for Designers & Developers | Figma
https://www.figma.com/design-handoff/
Figma
The Designer's Handbook for Developer Handoff | Figma Blog
https://www.figma.com/blog/the-designers-handbook-for-developer-handoff/
Zeplin
Design Delivery Checklist · Zeplin
https://zeplin.io/resources/design-delivery-checklist/
Zeplin
Downloading assets | Zeplin Help Center
https://support.zeplin.io/en/articles/1338605-downloading-assets
Referenced source
SVG QA Checklist: Web, Print, and Developer Handoff
https://svgverseai.com/blog/svg-qa-checklist-web-print-dev-handoff
Next step
Turn the idea into a build-ready plan.
AppWispr takes the research and packages it into a product brief, mockups, screenshots, and launch copy you can use right away.