AppWispr

Find what to build

Assets for Contractors: Exact Export Presets, File Names & Folder Structure Designers Must Deliver to Developers

AW

Written by AppWispr editorial

Return to blog
P
DH
AW

ASSETS FOR CONTRACTORS: EXACT EXPORT PRESETS, FILE NAMES & FOLDER STRUCTURE DESIGNERS MUST DELIVER TO DEVELOPERS

ProductApril 15, 20265 min read995 words

Stop sending vague 'see figma' packets and start handing off deterministic asset bundles. This guide gives founders and product builders exact export presets to set in Figma/Sketch, a strict file‑naming convention, and a reusable folder layout developers expect—plus a one‑page QA checklist contractors can sign. Follow this and you’ll remove the common back-and-forth that delays sprints.

export presets file naming folder structure assets-for-contractorsdesign handoffFigma export presetsasset naming conventionsdeveloper handoff checklistAppWispr

Section 1

Why precise assets matter (and the cost of fuzzy handoffs)

Link section

When designers deliver assets without explicit export scales, consistent names, or a predictable folder layout, developers spend time guessing what to import, rename, or recreate. That friction multiplies across screens and releases: a single blurred image, mismatched icon, or unknown naming scheme can cascade into staging bugs, layout regressions, and scope creep.

This guide rejects vague rules like “export retina versions” and replaces them with explicit presets, file name templates, and a folder tree developers can script against. Treat the design-to-dev handoff as an API: clear inputs (assets) + immutable contracts (names and layout) = predictable outputs (working UI).

  • Design assets are part of your engineering contract — make them machine-readable.
  • Use explicit export scales (1x/2x/3x) and vector formats (SVG) where appropriate.
  • Agree layer and component names with engineers once, then enforce them with templates or plugins.

Section 2

Exact export presets to set in Figma (and equivalent in Sketch)

Link section

Set export presets for each atomic asset type and add them to the component or frame before handing off. Use these as a baseline you can copy into a project plugin or library: Icons → SVG @1x (no raster), UI bitmaps (buttons, photos) → JPG or PNG at 1x, 2x, 3x depending on target density, Logos → SVG + PNG @1x and @2x for legacy places that require raster.

Concrete presets (apply to Figma export panel or set in Sketch exportable): Icons — Format: SVG; Size: 1x; Suffix: none. UI graphics (non-photographic) — Format: PNG; Sizes: 1x, 2x, 3x; Suffixes: , @2x, @3x. Photographic hero images — Format: JPG; Sizes: 1x, 2x; Quality: 80. Logos & illustrations — SVG + PNG @1x and @2x as fallback.

Notes: prefer SVG for icons and logos so engineers can manipulate them in code. Reserve PNG/JPG exports only when raster is required (complex illustrations with effects or photos). Use Figma’s color profile/document settings for consistent color; add export preset metadata in the file README page so contractors don’t have to ask.

  • Icons: SVG @1x (vector-first).
  • UI components: PNG @1x, @2x, @3x (use PNG for transparency).
  • Photos: JPG @1x, @2x (quality 70–85).
  • Logos: SVG + optional PNG @1x/@2x.

Section 3

File naming conventions that remove guesswork

Link section

Lock a single, simple naming convention for every file. Use kebab-case (lowercase, hyphens) or snake_case and avoid spaces or special characters. Include three pieces of structured information in the file name: component or asset key, purpose/variant, and scale suffix. Example pattern: component-purpose--variant@scale.format.

Practical examples: icon-search--filled@1x.svg, icon-search--filled@2x.png, hero-home--desktop@2x.jpg, logo-company--primary.svg. For stateful assets add the state token: button-primary--hover@1x.png. This deterministic pattern lets developers write build scripts that map assets to code names without manual renaming.

  • Pattern: <component>-<purpose>--<variant>@<scale>.<ext>
  • Use kebab-case; avoid spaces and uppercase letters.
  • Keep names short but descriptive; include scale suffix (@2x, @3x).

Section 4

A folder structure developers will love (and can script)

Link section

Deliver assets in a flat, predictable tree inside a feature folder. Top-level folders should be: /images, /icons, /logos, /illustrations, /fonts, /raw. Under each, keep feature subfolders (for example: /icons/auth, /images/home-hero). Avoid deeply nested trees; two levels is ideal and script-friendly.

Example tree (feature 'checkout'): checkout/assets/icons/, checkout/assets/images/, checkout/assets/logos/. Each file should follow the naming convention above so the build pipeline or a small node script can copy and rename assets into the app’s static assets folder automatically.

  • Top-level buckets: images, icons, logos, illustrations, fonts, raw.
  • Feature subfolders: keep nesting to one level (e.g., images/home, icons/auth).
  • Include a README.txt in each feature folder with export presets, color profile, and who signed off.

Section 5

One‑page QA checklist contractors must sign before delivery

Link section

Include a one‑page checklist inside the delivered zip and as the first page in Figma/Sketch. The checklist is binary (Yes/No) for each item; the contractor signs and dates it. Key items: All export presets applied? Files exported for required scales? Naming convention followed? Folder layout matched template? SVGs validated and optimized? README included with color/profile/token links?

Enforce the checklist as part of acceptance criteria in the contract—deliverables that fail the checklist are returned for a single revision. This small contractual step cuts review cycles and gives product teams a clear pass/fail gate for assets.

  • Checklist items: export presets, naming conformity, folder structure, README, color profile, vector vs raster justification.
  • Require contractor signature and last-updated date.
  • Make checklist part of acceptance criteria to avoid rework.

Sources used in this section

FAQ

Common follow-up questions

Should I always export @2x and @3x for every image?

No. Export multiple scales for UI bitmaps that will be used on high-density screens (1x, 2x, 3x), but prefer SVG for icons and logos so you can avoid raster scales. Export 2x/3x only where the UI implementation expects raster images (photos, complex illustrations).

When do I choose SVG vs PNG vs JPG?

Choose SVG for icons, logos, and any vector illustrations without raster effects. Use PNG when you need transparency or lossless quality for UI elements. Use JPG for photographic images where smaller file size matters; set quality between 70–85.

How do I make engineers trust the naming and structure?

Agree on the naming pattern with engineering once, add that pattern to a project README and the one‑page checklist, and enforce it at delivery. Provide a tiny script (or instructions) that maps delivered names to the app’s static assets folder—scripts build trust by removing manual steps.

Can I automate applying export presets in Figma?

Yes. Use export‑preset plugins or a shared component library where the export settings are baked into components. That reduces human error and keeps presets consistent across files.

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.

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.