The One-Tool Design Era Is Over. Nobody Solved the Handoff Problem.
Somewhere in the last two years, the design file at your company stopped being one file. It's a Figma board for the marketing site, an Excalidraw canvas for the product team's early sketches, a Penpot workspace someone on the design-eng team stood up because procurement wouldn't approve another seat, and a stack of AI-generated component variations living in whatever tool the intern who prototyped them happened to have open. Nobody planned this. It happened tool by tool, decision by decision, each one locally reasonable, and the result is a design practice that runs across five surfaces instead of one — with no equivalent of the thing a single shared file used to give you for free: everyone looking at the same source of truth.
The trigger is well documented and easy to point to. Figma's April 2024 pricing restructure — moving toward seat-based and usage-based charges across its plans — landed badly enough that it became a visible turning point rather than a quiet grumble. Penpot, the open-source Figma alternative, closed a Series B a few months later explicitly positioned against that exact frustration. Excalidraw picked up enterprise adoption for early-stage sketching that never needed Figma's full weight in the first place. Every design newsletter covered the pricing backlash. Almost none of them followed the thread to where it actually leads: once a team is running design work across multiple specialized tools instead of one general one, how do you coordinate any of it? That question has had eighteen months to get an answer, and it mostly hasn't.
The Coordination Cost Nobody Priced In
A single tool, whatever its flaws, gives you one thing implicitly: everyone who touches the design knows where to look. Comments, version history, component libraries, handoff specs — all of it lives in one place, findable by convention rather than by memory. Split the workflow across five tools and that property doesn't degrade gracefully, it disappears. Now "where's the current version" is a question with a real answer that depends on which stage of the process you're asking about, and "who approved this" requires cross-referencing a comment thread in one tool against a decision made verbally in a meeting referenced nowhere. None of the individual tools are worse at their specific job — Excalidraw is genuinely better for fast sketching than Figma ever was, and that's the whole reason teams adopted it. The job that got worse is the one none of them were ever responsible for: keeping the whole practice legible to everyone participating in it.
This is a real, measurable tax, and it's invisible in the tool-by-tool cost-benefit analysis that justified each individual switch. A team saves money moving early-stage exploration to Excalidraw. A team saves money moving simple internal tools to Penpot. Each decision is defensible in isolation. The sum of those decisions is a practice where "handoff" now means someone manually re-explaining context that used to be implicit in file structure, and that labor doesn't show up on anyone's tool-spend spreadsheet because it's absorbed as generalized meeting time and Slack messages instead of a line item anyone would think to cut.
Why the Migration Guides Stop at "Which Tool"
Every piece of coverage comparing Figma to its alternatives frames the decision as a single migration: leave Figma, land somewhere else, done. That framing was accurate in 2023. It stopped being accurate the moment teams started running two or three tools concurrently rather than picking one replacement — which is what actually happened, because different stages of design work have genuinely different requirements, and no single alternative does all of them as well as the fragmented specialist tools now do their individual slice. The "which tool should we switch to" question got answered. The follow-up question — how do multiple tools coordinate on one product without a shared source of truth — never got asked with the same seriousness, because it's a harder, less marketable problem. Nobody sells "the coordination layer between your five design tools" as a product category yet, so nobody's writing the deep-dive on how to build one.
The Version-Control Model Design Never Adopted
Software engineering solved an almost identical problem decades ago, and design tooling still hasn't borrowed the solution. Code lives across many tools — editors, terminals, CI systems, deployment dashboards — and none of that fragmentation causes chaos, because git sits underneath all of it as a single, tool-agnostic source of truth that every surface reads from and writes to. Design has no equivalent. Figma's file format is proprietary and closed; Penpot's is open but not yet a shared standard anyone else has adopted; there is no git-for-design that multiple specialized tools check into and out of. Every attempt at design version control so far has been a feature bolted onto one specific tool, which solves nothing once your workflow spans several. Until something plays that role — a genuinely tool-agnostic layer that Figma, Penpot, and whatever comes next can all treat as the record of what's actually current — the fragmentation problem doesn't get solved, it just gets managed slightly better by whichever team is disciplined enough to over-communicate manually.
So Actually — the Exodus Was a Symptom, Not the Story
The instinct is to read the last two years as "Figma lost its monopoly, alternatives won." That's true and also beside the point. The more consequential fact is that design work matured past the assumption that one general-purpose tool could serve every stage of it well — sketching, prototyping, component systems, and handoff genuinely benefit from different tools now — and the industry hasn't built the connective tissue that maturity requires. Teams got better tools for each individual job and a worse picture of the whole. That's not a pricing story. It's a coordination story that pricing happened to kick off, and it's the one nobody's written yet, possibly because there's no single villain to blame it on the way there was in 2024.
This sits next to the governance vacuum that shows up once a design system has no clear owner — both are versions of the same underlying failure: tools and systems that work fine individually and quietly stop cohering once nobody's job is to hold the whole picture together.
If your team is running design across three tools right now and calling it flexibility, check whether anyone could actually answer "what's current" without opening a Slack search first. If they can't, you haven't modernized your tooling. You've just distributed the confusion more evenly.