Bringing engineering into the design conversation early

Design and engineering pull product teams in different directions: developers optimize for performance and stability, designers for consistent, elegant interfaces. Handoff—the move from design to build—is where those differences surface most sharply. Jake Albaugh frames the relationship simply: design is "what we want," development is essentially "what we have." Closing that gap depends on curiosity, an open line of communication, and a shared point of view on what "good" looks like.

Four focus areas translate those principles into daily practice.

Align on what you're building

A developer can be brought in at any stage, and earlier is generally better—whether you have an initial wireframe or just need a gut check on feasibility. An engineering perspective can flag technical logic that makes a simple-looking design decision hard to build, and can proactively surface opportunities the design team might otherwise miss. That feedback lands best while ideas are still pliable.

The goals at this stage are straightforward:

  • Align on scope
  • Understand constraints
  • Identify potential issues—or opportunities

Wireframes as a foundation for feedback

Illustrative wireframes are one of the best ways to get feedback on a design direction. Figma suits more concrete visuals; FigJam works well when you want to stay gestural or need neutral ground for outside collaborators to weigh in. Staying away from "realistic" visuals also keeps attention on the bigger picture and lowers the barrier for cross-functional participation. GitHub, for example, uses the code block tool in FigJam to align on component APIs across design system documentation and development workflows.

Questions that surface engineering detail

Developers readily spot redundant work and can suggest consolidating or extending existing functionality to get more design with less engineering effort—but they won't volunteer what you don't know to ask about. A few pointed questions help:

  • Ask about constraints, including friction at the data layer, which is a frequently overlooked source of complexity.
  • Ask them to flag states you may have missed when presenting a sequence of screens.
  • Ask them to identify underlying patterns you can reuse from elsewhere in the product.

Meeting developers in their tools

Developers context-switch constantly in pursuit of flow state, so meeting them where they already work builds trust and gets you what you need faster. Asking about their preferred workflow is worthwhile; regardless of the answer, embedding Figma in the tools they use is a good start. For asynchronous feedback:

  • Mention developers by name in comments.
  • Mark sections of wireframes as ready for dev.
  • Use audio chat in a file for quick syncs.
  • Send links to prototypes for more evolved drafts.
  • Embed prototypes into Figma Slides to produce an easier-to-digest artifact.

Designing for how it will actually be built

A design's real output is not the Figma file but the interactive experience that ships. Keeping your mental model close to your developer's implementation approach matters, in the same way an architect knows the materials, costs, and tools the builders will work with.

  • Think in the same terms your developer uses
  • Design for responsiveness and accessibility
  • Let differentiation come from implementation-aware decisions

Responsiveness goes past breakpoints

The web is responsive by default, and a design has to hold up in many forms. For developers, that means more than hitting named breakpoints — it means ensuring layouts render correctly in the space between them. A seemingly simple instruction like "25% width" can turn out to be far more involved in context:

width: calc(25% - (var(--gap-size) * 3 / 4));

That expression describes an item at 25% of its container, minus three gaps split four ways; calc() in CSS lets developers express dimensions as calculations instead of fixed values. Scale that up to a column that is ⅓ on tablet, ¼ on desktop, and ½ on mobile, and the complexity compounds. Layout often accounts for a large share of the work between Figma and build, so understand existing systems and defer to them where you can.

Lime green, red, purple, and blue shapes on a purple background.

Figma's annotations let you flag the details that make implementation harder.

Every build exists in more forms than were explicitly planned. Users can resize windows, raise their base font size, or supply custom theming. This variance is part of why developers hold design decisions more loosely; designers who set a parent frame are instead locking in a snapshot of constraints so they can focus and iterate. That focus makes it easy to lose the wider picture.

Zooming out in practice

  • Work out how elements transform between breakpoints
  • Separate non-negotiables from nice-to-haves
  • Keep an annotation category dedicated to layout
  • Learn how aspect ratio lock and min/max dimensions affect development
Abstract shapes on a pink, purple, and green background.

In their Config 2023 talk, Una Kravets and Adam Argyle describe responsiveness as broader than breakpoints — an evolution that includes responding to user needs and preferences.

Design for content you can't control

Polished mockups with perfect copy and high-resolution images break down against user-provided content: orphaned words, low-resolution photos, partially completed profiles. Even anticipated content can behave unexpectedly under real constraints. Consider how text wrapping produces undesirable line heights, how truncation lands, and how user font-size preferences change the page. Bringing build implications into the design itself raises quality and avoids backtracking after handoff.

  • Use content variables with modes to test text across languages and lengths
  • Populate text values with realistic content via Figma AI
  • Generate images that aren't biased to match the surrounding UI

Accessibility is structural, not just visual

Accessibility is a pillar of good design. Color is the shared concern most designers know, but developers also make structural decisions that shape the user experience beneath the visuals. Because HTML is semantic, large text is not necessarily announced as a heading by a screen reader or treated as one in the page context. In some systems, links inside a text block are distinct functional components in code, and a grid of cards may be coded as an unordered list. You may never call these details out in a mockup, yet your decisions influence how they get built — knowing the invisible concepts is an opening to talk with your developers.

Annotating interactive behavior helps too. A clickable HTML anchor behaves differently from a button: anchors change the URL, while buttons carry other kinds of interactivity. Understanding that difference tells you what a developer needs from you — the destination URL for a link, for example, or click analytics. When a whole card is clickable, best practice is that none of its descendants carry different click events. Thinking through tab order makes this concrete, and it is an opportunity to bring intent into complex interaction flows rather than treat it as a browser constraint.

  • Check contrast with the accessibility color picker
  • Ask developers how concepts are expressed in code
  • Edit annotations in Design mode under an "Accessibility" category

Treat developers as strategic partners

Implementation awareness isn't only about accepting limits — it's also about finding room to differentiate. Developers can point to web capabilities you may not know about: colors and gradients on the web are quite advanced today, and they may have useful perspectives on animation, typography, grid-based layout, and container queries.

Two people and a cat paint abstracted versions of file tabs in an internet browser.

In that memo on where the web is headed, Jake shares the technologies he's most excited about and how to tap the browser's creative potential.

  • Ask developers which concepts could become a design differentiator
  • Stay curious about new layout patterns and approaches
  • Have them share the front-end technologies they find most exciting — shifting constraints can open innovative approaches

Designers and developers often describe the same thing in different terms, and color is a reliable place for that gap to surface. A designer may apply the latest Figma variables assuming they mirror the codebase, only to see the colors render differently in the build. Even when the correct token is used, its underlying value may be stale—and manually picking a different token to match the mockup tends to break again on the next update. Catching these mismatches early means aligning design decisions with existing code patterns before handoff rather than after.

Build on the design system

A design system's efficiency and consistency only materialize when both sides use it as intended. It already carries shared patterns whose values are aligned across design and code—component names, properties, variables—and although they rarely match one-to-one, they are structured to surface the right information in the right context.

The structures differ by necessity. A Figma library might use groups or slash-naming to organize variables, or combine instance swap properties with booleans; in code, the boolean and swap instance may collapse into a single prop that appears only when true, and variables are formatted for styling. Features like code syntax and Code Connect let the system serve both audiences: designers see what they need in Figma, developers receive structured data in code.

When an existing component doesn't quite fit, prefer modifying it and follow the design systems team's process for the change. If the work needs a genuinely new design and build, decide with your developer which system resources it can reuse and whether it belongs in the system or should remain a one-off. Document the use case, the proposed changes, and how the design and code assets should be contributed.

  • Link design-friendly names to existing code with code syntax or Code Connect.
  • Default to modifying existing components instead of creating new ones.
  • Involve the design systems team for larger changes.

Align with layout conventions and typography

Freeform work should still follow existing spatial systems: check Figma for published Layout grid styles or template components, and if none exist, look for documentation on ratios and spacing. Chances are the codebase already has layout conventions—containers, stacks, grids—that can inform design decisions. When something must be built from scratch, work with the developer on the approach. Figma's Simple Design System illustrates how component language can describe layout: its flex component handles auto layout-like flows with default responsive behavior, and its section component covers full-bleed page sections.

Text styles establish structure, not just font family, size, and weight. Resist tweaking a heading or title style to control visual weight, since each style has a purpose—and in code, heading elements carry accessibility and hierarchy implications. If the mapping isn't obvious, discuss it: should that title become an H1 or an H3, or use a typography abstraction with a specific prop? Inline elements add another layer—a Figma style may apply an underline where code uses a dedicated link component—and a heading that must also be a link can create inconsistencies without agreed guidelines. Settle expected behaviors early and document how they translate between design and development.

  • Use design system styles as intended and verify their code implementation.
  • Document intended mappings and behaviors.
  • Account for accessibility and hierarchy when translating styles to code.

Prepare the handoff file

A tidy file is the foundation for accurate translation. Layer names matter because developers rely on them when inspecting a design and building the structure in code: "Frame 123" reads as a generic div, forcing the developer to guess intent, while names like feature callout, main content, or related aside let them choose proper tags and attributes. Name layers manually or with Figma AI, and delete unnecessary layers to reduce confusion.

For images, icons, and illustrations pulled directly from the file, pre-set export settings in the sizes and formats the developer needs, and say so as part of the handoff; they can add exports or reach the raw image through Dev Mode if requirements change. Also check that typography, fills, and spacing use the right styles and variables, along with correct component properties and variants—assets used as intended are largely self-documenting through prop alignment, code syntax, and Code Connect. If you detached a component or deviated from the system, explain why: component details survive in Dev Mode, a comment thread supports asynchronous discussion, and an annotation records the final details.

  • Name layers manually or via Figma AI; clean up and order the layer panel.
  • Pre-set export settings for assets used from the file.
  • Note when objects come from external resource links.
  • Justify detached components with comments or annotations.

Annotate in Dev Mode and mark ready

Dev Mode shows the design from the developer's perspective. Annotate the details that would otherwise be lost, so they surface in the main Dev Mode view:

  • Spacing, measurements, and whether a value is fixed or responsive.
  • Properties needing extra context, flagged with annotations.
  • Asset locations—for example, an image pulled from a CMS versus taken from the design.

Once the file is prepared and reviewed, tag the relevant sections or frames with the "Ready for dev" status as a clear signal of what is finalized. Do a final Dev Mode pass to see exactly what the developer will see, then share the Dev Mode link and stay available for initial questions. Comments covering anything that changed after the first handoff can go through Dev Mode statuses and notifications.

No single process fits every team; whether the workflow is linear or iterative, what matters is alignment around shared goals while respecting each discipline's perspective. Teams that hand off well treat it not as a single moment but as a gradual build of shared understanding between designers and developers.