cover image -- stackblitz

What do developers want in a design handoff? We asked them

Nick Moore
Written by Nick Moore
Jun 17, 2024

Many of the most persistent development problems are hiding under “that’s just how it is.” These are the processes that feel inherently slow, the steps that always seem to require over-communication, the workflows that inevitably go well one day and poorly the next. 

People get frustrated, but it’s often hard to step back and say, “How could we do this better?” When the process works well enough, it’s hard to recognize how the process could go from “good enough” to great.

Enter the design handoff. 

A smooth design-to-dev workflow helps teams streamline handoff and deliver higher-quality experiences.

When designers finish designing an app and deliver the design specs to the development team to build, mutual frustration frequently ensues. The design team is worried the development team won’t realize their vision and the development team is worried about all the back-and-forth that will be necessary to make sure they’re actually building what needs to be built. 

Thought leaders and vendors have ideas about “design ops” or about eliminating handoffs altogether, but we wanted to focus, first and foremost, on mutual understanding. Many design handoff issues lie downstream from the fact that designers often just don’t know what developers want. So, we took the time to ask them.

What pain points do developers experience when receiving a design?

For Donnie D'Amato, founder and chief architect at Design Systems House, the design handoff often immediately creates friction because the meaning of the work has been lost in the process. There’s rarely enough context, and he always has questions: “What is the purpose of me doing this work? Why did we decide to go in this direction when it isn’t obvious that it’s the right direction?” 

Designers, who likely don’t intend to, can make developers feel like short-order cooks just taking tickets and following directions. “Sometimes,” D'Amato says, “I feel that we’re left out. As developers, we don’t know the entire story about where this design came from.”

When developers are left out, it can be difficult to give context back to the designers, too. 

Daniel Vaughn, Senior Platform Engineer at NextEra Mobility, explains how tedious it can get to account for every variation a UI goes through after its first state. “A handoff may show me a layout at 1280px and 480px screen widths, but I don't know how the layout is intended to change between them,” he says. “Or a handoff may show me how to style the title of a blog post but does not address what happens when the title is longer than the width of its container. Does it wrap, or should it be truncated with an ellipsis?”

The tedium is a bigger problem than it might first appear. Morale can drop on both sides when efficiency is slow, and the more developers are left to improvise to fill in the blanks, the more likely designers will be unsatisfied with the results. 

Ben Nadel, an engineer at Invision, explains that designs often “don't speak to the reasons that a feature was designed; or to the trade-offs that were considered along the way; or, to the very real pain that your customers are currently experiencing. Engineers, he writes, are “going to have to make a lot of educated decisions along the way,” and they “can't make an educated decision without all of the facts.”

What do developers wish designers understood better about the development side of design handoffs?

There’s a lot of hope before and after the design handoff. Designers hope developers have all the information they need, and developers hope designers keep their needs in mind when they build those designs. 

The ideal handoff, however, shouldn’t rely on hope – designers should know exactly what developers need or what questions to ask to determine those needs.  

For Vaughn, the primary thing he wishes designers understood better is that it’s a good handoff is all about the details. “For us,”  Vaughn says, “The concrete details are the most important. The hex values, the image assets, the pixel dimensions—a handoff could literally just be those details, and we'd still be able to implement the design correctly.”

“The more that designers understand development, even in a small slice, the more beneficial.” 

  • Donnie D'Amato, founder and chief architect at Design Systems House

Developers reading this will likely respond with, “Of course!” but designers don’t always find this level of granularity intuitive because many of them don’t code. 

There are hot takes going back and forth on this subject – some people think designers should be proficient programmers, some think designers should focus on their specialization, and others fall somewhere in the middle. 

D’Amato’s argument, however, is simple: “People who understand their medium in art or design do better than folks who don’t.” Just like a painter needs to know which paints to pick and how each paint will affect their canvas, so does a designer need to have some familiarity with the materials and resources at hand. 

That said, designers don’t need to be professional-level programmers. As D’Amato says, “The more that designers understand development, even in a small slice, the more beneficial.”

By understanding code a little bit, designers can better understand what developers need from them and better see how every design and code change links up to a bigger picture. From this perspective, designers can shift from sometimes seeing developers as killjoys to seeing developers as systems thinkers.

“It’s not that we don’t want to do the cool or amazing or interesting stuff,” D’Amato explains. “It’s a matter of thinking about things systematically. That’s what developers do.”

When developers receive an ambitious or complex design, they have to think both about building it and maintaining it. The designer might have been thoughtful in the former but not the latter. 

If a designer wants to load six different fonts on the same page, for example, developers could be on board with the cool design but skeptical of the impact on performance. “The more fonts that you load in the page, the more requests that you have to make for different assets, and the heavier the page ends up being,” D’Amato says. 

With an understanding of granularity, code, and systems thinking, designers can better understand the balance developers are trying to strike. “There’s a balance that you have to always pay attention to,” D’Amato says, “And I would hope that designers understand that that’s what we’re trying to balance.”

What is the developer experience like when using design tools?

When people criticize the design handoff experience, they often focus on communication between designers and developers, but much of this communication is waylaid by tooling. 

Even Figma, which is often the default for design teams, only introduced a dev mode in January 2024. This isn’t a criticism of the company or the tool but an example of how often designers are trying to hand off designs to developers within tooling that wasn’t really built with that purpose in mind. 

Vaughn is blunt, saying, “Most developers I've known don't feel very comfortable navigating design tools.” As a result, he says, “I'm not sure I've ever had a handoff where I felt truly comfortable navigating the handoff artifacts.”

Developers often get lost in a thorny web of design files, for example, and struggle to figure out which file they should reference when. Vaughn argues that “Design tools should empower designers to clearly distinguish the ‘source of truth’ from what I call the ‘source of falsity,’ i.e., the mountain of little experiments and drafts that are inherent to the creative process.” 

This is an important bottleneck. Developers aren’t the primary users of these design tools, but if the work grinds to a halt when the handoff begins, then the tooling isn’t working. After all, the goal is to build products, not designs. 

D'Amato is clear that developers have some work to do here, too. “It’s important for developers to be able to traverse files. They need to be able to see the things that they’re about to build and the specifications that they need to understand to build it properly.”

Vaughn makes another analogy, “If an architect builds something in CAD, prints it out as a blueprint, and hands off the blueprint, the person who’s walking through the model doesn’t need to know how to use CAD in order to do that.”

“I don’t feel comfortable in design tools, and that’s fine,” Vaughn explains. “You should know how to traverse Figma. You should know how to be able to zoom in and zoom out. You should be able to leave comments.” 

The more designers and developers can meet in the middle to communicate their needs and their tooling familiarity, the better they can close any gaps in communication or experience. 

What makes for an ideal design handoff?

The more design and development teams learn about what the other needs, the more we can start talking about what makes for a truly great design handoff. 

For Vaughn, an ideal design handoff process is one that “empowers developers to faithfully bring the designer's vision to life with as little toil as possible.” Though the goal is empowerment on both sides of the equation, the process needn’t be heavyweight or overwrought to achieve this. As Vaughn says, “The process should be as invisible as possible.” 

He compares it to an effective CI/CD system, which allows developers to make changes and trust, with little manual effort on their own, that those changes will be automatically tested and deployed. The industry shift to CI/CD “massively reduces the amount of labor required to develop a product,” Vaugh says, but tooling and workflow changes still remain to be done for the average design handoff process to become as effective and as invisible. 

“The ‘ideal’ process will forever be a moving target.”

  • Daniel Vaughn, Senior Platform Engineer at NextEra Mobility

For D'Amato, a foundational element of the design handoff becoming this effective is designers learning just how detailed their designs and specs need to be before they’re ready for handoff. 

“We’re talking about the tokens that I’m using to compose these things and all the different types of states that we need to consider. And that’s not just hover and active,” D’Amato says. “We’re talking about things like empty states or first-time user experience stuff. All the different considerations need to be accounted for.”

Nadel concurs, warning that “Over time, both designers and developers tend to forget that a new user is going to have an experience that is radically different from their own. As such, when you receive a new design, make sure that you consider the possibility of an empty state - what it looks like when a user has no data. And if that's not present in the design, ask the designer to go back and add an empty state to the prototype.” 

That said, Vaughn warns, the ideal design handoff won’t be one, whether good or bad, that’s frozen in time. “As time marches forward,” Vaughn explains, “The technological landscape changes, the product changes, and customer needs change. Therefore, the ‘ideal’ process will forever be a moving target.”

It’s worthwhile work both on logistical and morale levels. D'Amato warns that the handoff process has “absolutely” led to antagonism between developers and designers before. “This is not a dream world we’re talking about here,” he says. 

There’s a lot of work that goes into a design – from the designers themselves as well as all the work culminating in the design – so simple increases in transparency can do a lot to reduce the likelihood of conflict. “The more that you provide in terms of the information, the less antagonism I think you’ll find for developers,” D'Amato says.

How do design systems help facilitate the design handoff process?

The developers we talked to agreed that even though better communication could smooth out the design handoff, improvements in tooling and systems are necessary to turn the design handoff into what it needs to be. In particular? Design systems: Collections of components and standards that developers and designers can reference, reuse, and build from. 

“The point of a design system is to break.”

  • Daniel Vaughn, Senior Platform Engineer at NextEra Mobility

“The beauty of design systems,” D’Amato says, “is that there should be resources that you can use to build experiences very quickly.” The rapidity isn’t about sheer speed, however, it’s about giving developers and designers the space and material to discover agreements and disagreements. “

Vaughn explains, arguing, “The point of a design system is to break.” From his perspective, every company and team has a design system of sorts, but some are explicit, and some are implicit. 

All systems break, but “the problem with implicit systems is that they fail silently.” When an explicit design system fails, as it inevitably does, people know. “Without an explicit design system,” he says, “No alarm bells are going to magically go off if a designer creates two similar but incoherent buttons on two different pages.”

“Once is an instance. Twice as a coincidence. And third is a component.”

  • Donnie D'Amato, founder and chief architect at Design Systems House

These alarm bells are important, both because they warn the teams of potentially misaligned designs but also because they signal friction. As D'Amato explains, the design work can often result in “novel concepts that cause friction.”

Novel concepts aren’t bad, per se, but they need to be tracked. D’Amato advises teams to think of it like this, “Once is an instance. Twice as a coincidence. And third is a component.” There are many reasons to go ahead and build a novel feature, but teams that track those requests know much sooner when they need to invest in turning that once-novel feature into a reusable component. 

With a design system in place, developers and designers can have better conversations and more productive questions. Brian Coords, a WordPress developer, explains, “The development work starts before you write code, before you set up your local environment. It starts in that handoff, where your experiences shape your decisions just as much as the designs themselves do.” It’s there that you ask questions like, “How will each of these components come to life? How many options or settings will I give the client? How flexible will these components be? How rigid?”

The goal isn’t sheer efficiency (though that’s a great thing to pursue, too). By giving developers components they can grab from a preexisting library, D’Amato says, designers can give developers more space to “build these experiences and identify what parts of the experience they might need to build custom.” 

Bottlenecks and starved workflows

In The Phoenix Project, a classic work that drove much of the initial discussion around DevOps, the authors write about systems and workflows – taking particular issue with bottlenecks that cause more severe problems than participants might realize. 

The authors write, “Any improvement made after the bottleneck is useless because it will always remain starved, waiting for work from the bottleneck. And any improvements made before the bottleneck merely results in more inventory piling up at the bottleneck.” When you identify bottlenecks, in other words, you can’t just fix one side or the other; the bottleneck itself requires change. 

The bottleneck, in this case, is the design handoff. When you’re used to a bottleneck, the entire problem can go understated and unseen. But the productivity, morale, and alignment problems persist. If the design handoff is a bottleneck, then no one on either side will be happy.

For most teams, as D’Amato explains, developers “don’t know where this information came from or where this design is meant to go or what it’s meant to solve. They throw it over the fence and say, “Here you go, developer, good luck and Godspeed!” Just as developers once threw code “over the wall” to IT staff to deploy, so do designers tend to throw designs over the wall to developers. In both cases, the problem wasn’t individual – it’s systemic. 

As Vaughn says, the design handoff “is not efficient. Improving our processes requires rethinking some fundamental assumptions about what design is and how it's done. As an industry, we should be actively experimenting with new modes of working, even if they are initially unfamiliar or even uncomfortable.”

Nick Moore
Nick Moore
Try zeroheight
The design systems platform that keeps teams and agents in sync
Start for free
Share this post