Design Handoff Checklist

The Brief

A design-to-dev handoff protocol for 15 teams

At enterprise scale — 15 teams, 150+ developers, 15 designers — delivery had stalled under years of accumulated process debt. Handoff was a black box: components got reused inconsistently across teams, or skipped altogether, producing a "Frankenstein" UI where one team's primary button was another team's secondary link. A cultural assumption that our (older) user base didn't use mobile devices meant there was no responsive documentation at all — FullStory data showed the resulting frustration directly, in the mobile and tablet sessions that were happening anyway.

The Problem

An alignment gap, not a tooling gap

Despite having a shared component library, teams treated it as a suggestion rather than a standard. The "Desktop-Only" myth meant no team had ever documented mobile breakpoints or interaction states, so developers guessed at layout behavior on smaller screens. And because handoff lived as tribal knowledge in each designer's files, work became an indecipherable maze the moment a designer went on vacation or left the company — stalling engineering until someone could reverse-engineer intent.

The Process

Listening first, then engineering the gate

I started with a status-quo audit — interviewing designers and engineers across all 15 teams to document where the cost of inconsistency actually showed up, and using FullStory data to confirm the mobile frustration was real. I piloted the new responsive-first protocol on my own team first, which surfaced the actual gaps in our component library (mobile-friendly variants, mostly) before asking anyone else to adopt it. Winning over senior designers meant reframing the work: not as extra process, but as an accessibility and legacy project that protected junior designers from having to guess.

From there I turned the Jira workflow itself into the gate. I built a mandatory Design Sub-task — a Ready-for-Dev checklist — that no story could clear without documented mobile breakpoints, state logic (loading, error, empty), and interaction logic (tap vs. click). A centralized Knowledge Base held the resulting source-of-truth documentation, and a Customization Pipeline gave teams a formal path to submit new components for vetting into the shared library instead of freelancing their own.

The Solution

A shared contract — and a case for automating it further

The protocol replaced "design-by-developer" guesswork with a standardized contract across all 15 teams. Rework dropped as the source of truth got established before a sprint began instead of getting negotiated mid-build, and the "black box" problem disappeared — any engineer or designer could pick up a ticket and understand the full intent, even across a handoff between people. FullStory sessions showed a measurable drop in user frustration as the UI became consistent and accessible across devices for the first time.

The bigger lesson was that scaling a process across 200+ people is a human problem before it's a technical one — mentorship and advocacy moved veteran designers faster than a mandate would have. At larger scale, I'd want to move the Ready-for-Dev gate from social governance (checklists and meetings) to technical governance: automating it through Figma linting plugins that check for mobile breakpoints and token usage, so the gatekeeper role moves from a person to a tool.