The acquisition that wasn't
Adobe announced the acquisition of Figma in September 2022 for approximately twenty billion dollars — at the time, the largest acquisition ever attempted in enterprise software. Regulators in the European Union and the United Kingdom raised serious competition concerns. In December 2023, Adobe and Figma called it off, paying Figma a one-billion-dollar breakup fee. By then Figma had been working under acquisition shadow for fifteen months, and the industry had watched very closely to see whether that shadow changed anything about the product.
It didn't. Figma shipped Dev Mode in 2023, variable font inspection, and a restructured component property panel. The team did not appear to be coasting on an acquisition premium. When the deal collapsed, Adobe's announced abandonment of the purchase was read widely as a regulatory correction, and Figma's independence was treated as the natural state of things — because for most practitioners it already felt that way. Nobody had switched tools in anticipation of the deal closing. Nobody switched back when it fell apart.
The file as the argument
What Figma actually changed, over the years from its 2016 launch through to the present, is where the productive disagreement between designers and engineers happens. Before browser-based, multiplayer design tools, that disagreement happened in handoff — a PDF, a Zeplin link, a stack of Sketch artboards exported and emailed. The designer's intent arrived at the engineer's desk as a finished artefact, and the negotiation that followed was a correction process. Something was built wrong; it needed fixing. The designer's original reasoning was already absent from the room.
- September 2022Adobe announces ~$20 billion acquisition of Figma
- December 2023deal abandoned; Adobe pays $1 billion breakup fee
- 2016Figma public launch
- 2019Auto Layout introduced
- 2022Auto Layout substantially extended (gap, padding model)
- 2023Dev Mode shipped; Variables panel introduced; container queries reach all major engines
- 2024Figma ships new rendering engine
In a live Figma file, the reasoning is in the room. An engineer inspecting a component in Dev Mode sees not just the value — the spacing token, the colour, the font size — but the structure the designer built around it. A component with twelve variants and a Boolean property for an icon reveals, through its own organisation, the decisions that led to it. That revelation is sometimes uncomfortable. It surfaces assumptions the designer made about what was easy to implement, and assumptions the engineer made about what was easy to describe. The file is where those assumptions collide before any code is written, which is an improvement on colliding after.
Nobody had switched tools in anticipation of the deal closing.
Design tokens are part of this. When a Figma file uses a published token library — colours and spacing values that map to named variables in the codebase — inspection and implementation speak the same language. The token color/surface/default means the same thing in the file and in the stylesheet. The argument, when it happens, is about the right abstraction, not a hex value that drifted between tools. Figma's Variables panel, introduced in 2023, brought token-style scoping natively into the file: a variable can be scoped to a specific property, carry multiple modes, and travel out of the file through the REST API into whatever build system the team runs.
Container queries live here too
The tool is not neutral about technology. When Figma introduced Auto Layout in 2019 and extended it substantially in 2022, it was teaching a generation of designers to think in flex terms — main axis, cross axis, gap, padding — before they had written a line of CSS. That alignment with the web's actual layout model was not accidental. When container queries reached every major engine in 2023, Figma's component model was already closer to that mental model than any frame-based tool had been. A component in Auto Layout that responds to its content width is, conceptually, a component that should respond to its container. The tool had been preparing designers for the spec without explicitly saying so.
This is one of the more interesting things about Figma's position: it shapes the vocabulary. Designers who have worked in Figma for several years describe layout in terms — hug, fill, fixed — that are Figma's own, but they map cleanly onto fit-content, 1fr, and explicit pixel values in CSS. The vocabulary is proprietary; the underlying concept is the web platform. When the conversation between designer and engineer is good, that mapping is transparent. When it isn't, the Figma terminology becomes a dialect problem.
Criticisms that stick
Figma's collaboration model is genuinely good; its performance at scale is less so. Large files — a design system with hundreds of components, a product with thirty screens — slow down noticeably in the browser canvas. The team has shipped rendering improvements, moved more work to WebAssembly, and the 2024 move to a new engine addressed some of this, but the problem is structural: everything lives in one document graph, and that graph gets large. Teams that have worked around this by splitting their libraries across multiple files describe the workaround as load-bearing. It is not elegant.
The pricing structure (as of early 2025 on Figma's own pricing page) places advanced collaboration features behind the Organisation tier, which runs at a per-seat annual cost that is meaningful for small teams. Free and Professional tiers exist, but the serious collaboration features — branching, variable publishing, design system analytics — require the higher tier. That cost is where many small studios feel the product's enterprise orientation most directly. Figma's market is clearly large product teams; the tool's economics are calibrated accordingly.
What stayed
The abandonment of the Adobe acquisition changed very little about daily practice. Designers still open Figma in the morning. Engineers still inspect components in Dev Mode. The argument about whether a spacing value should be 16 or 20, whether this variant should be a component property or a separate component, whether the token name is right — that argument still happens in the file, in a comment thread, in a Slack message that links back to the file. Figma did not invent the argument. It moved it earlier in the process, closer to the design decision and further from the shipped code. That is the actual product: not the canvas, not the multiplayer cursor, but the earlier collision, which is cheaper to resolve than the later one.
The tools that collapse the handoff further — Webflow, Framer — push the argument further still, toward the output. Figma sits deliberately short of that. It makes the design artefact and the code artefact speak to each other; it does not pretend they are the same artefact. That restraint, more than any feature, is what kept the industry working in it while regulators took fifteen months to decide its ownership.