Designers don't need Figma anymore

Figma costs us about $21,000 a year, and I'd rather spend that money on tokens.

I don't mean design tokens. I mean the tokens a model is billed in. Most companies I talk to are doing the same arithmetic this year. Money that sat in seat licenses is moving to model usage, because that's where the work went.

The work did go. Designers on my team work in the production code now. They open pull requests against the same components and tokens the engineers ship.

When someone needs to see an idea before it's built, Claude makes a visual artifact in a few minutes. It's a page that runs, at the size it will ship, that anybody can open from a link.

So the canvas gets opened less and less. Paying for an expensive app at our level of use is a habit, not a decision, and I'd like to make the decision.

A seat decides who gets to take part

Per-seat pricing does something quietly that nobody chose on purpose. It decides who participates in design.

Editors are designers, because editor seats cost money. Everybody else gets a view link. That includes the researcher, the product manager, the engineer who spotted the problem and the contractor whose access ended with the contract.

They can look at a decision. Mostly they can't touch it, and some of them never see it until it arrives as a screenshot in a chat thread.

When the design lives in the running product, the gate is a review and not a license. That's a better gate. It still isn't open to everyone, but the person who can't afford a seat is no longer the one left out.

There are options at very different stages

None of these has to replace Figma on its own. Nothing we do now needs one tool that does everything.

• Penpot (opens in a new tab) is the one I'm moving to. It's open source, runs in the browser and can be self-hosted. It has native design tokens, and its layout is CSS flex and grid, so a layout in the file maps to a layout in the code. It also has an MCP server. MCP, the Model Context Protocol, is the standard way an agent connects to a tool, so an agent can work in the file.
• FigCraft (opens in a new tab) is a native design app, free and open source, with no account and no subscription. It works offline. It's also in early alpha, at version 0.5, so I wouldn't put a team on it yet. I'm watching it.
• Google Stitch (opens in a new tab) generates screens from a prompt or a sketch and exports code. It's good for the first hour of an idea, and it's free in beta with daily limits.
• Claude makes visual artifacts: running pages, diagrams and prototypes that can be shared with a link and changed in conversation.

The history is the expensive part

Cancelling takes one click, but the history doesn't move on its own.

Our design system lives in Figma: tokens, components, thousands of icons, the pages that document them, and the patterns built from them. Years of decisions are recorded there in a format only one company can open.

So before I cut the cord, I made a copy that doesn't need Figma to be read. Claude Code did most of the running, through Figma's MCP server, and I set the order and checked the results. This is the plan, in the order it runs.

FigmaBackup repositoryPenpot

1. 1FigmaTake an inventoryEvery file listed, and why it stays or goes.
2. 2Backup repositoryExport the recordVariables, styles, components, icons and every page's layers.
3. 3Backup repositoryKeep exact copiesNative .fig files, the only exact restore.
4. 4Backup repositoryProve the copyFingerprints match, and one restore went back into Figma.Nothing moves until this passes
5. 5FigmaFix the defectsA mess migrates as faithfully as good work. Then export again.
6. 6PenpotMove the tokensOne set per theme mode, every guess logged.
7. 7PenpotMove everything elseIcons, documentation, components, patterns, then reconnect tokens.
8. 8PenpotCheck with the people who use itEach person, the way they already work.The team decides, not the plan
9. 9FigmaCancelOnly now.

1. Take an inventory. Every file in the design-system team is listed, with whether it's backed up and why not. Empty, test and scaffold files are written down and left behind on purpose.
2. Export what can't be rebuilt from pictures. That means over a thousand variables, across three collections and five theme modes. Each one keeps its value in every mode, its references, its scope and its description.
3. Export the rest of the record. Text and effect styles, every component's properties and variants, about four thousand icons as SVG files, and the full layer tree of every page.
4. Make the copy prove itself. Each export carries a fingerprint computed inside Figma. A check confirms every file opens, matches its fingerprint and count, and that every token reference points at a token that exists.
5. Keep an exact copy too. Native .fig files are the only format that restores a Figma library exactly. I tested it: all thirteen files went back in, and every component, variable, style and icon matched the backup.
6. Fix the defects in Figma before moving them. A broken component set, tokens that skip the semantic layer, and two live versions of the same app shell and modal. A migration moves a mess as faithfully as it moves good work.
7. Move tokens first. A converter writes Penpot's token format, with one set per theme mode and themes that switch between them.
8. Then everything else, in dependency order. Icons, then the documentation library, then component libraries starting with the smallest, then patterns and templates.
9. Check that the people who'll use it can. That means each of them, the way they already work: a keyboard alone, zoom, voice control or a screen reader. The canvas may never work by ear in any tool, but comments, specs and tokens should. A tool part of the team can't operate isn't cheaper. I haven't done this yet, so it happens before we commit.

Two details taught me the most. Figma's public API doesn't expose variables below its Enterprise plan, so the token export runs as a script inside Figma. That's a small, concrete lesson in what lock-in looks like.

The other is that Figma's number variables carry no unit. The converter has to infer whether a value is spacing, a radius or a font size from its name and scope. Every guess, rename and skipped value goes into a log that a person reads.

Components come over through Penpot's own Figma exporter. It brings values and not the links to tokens. So each imported library gets reconnected to its tokens, and checked against the recorded list of its properties and variants.

I've written the whole plan up as a prompt for Claude Code (opens in a new tab). It covers the inventory, the backup scripts, the checks and the move, with each of these lessons built in. Fill in your team and your target app, and it stops for your decision before anything leaves Figma.

I can't tell you yet whether the move will hold up for a whole team. What I can say is that if it doesn't, the exact copy means there's a way back.

If you're paying for a tool your team rarely opens, look at what's inside it before you look at the price. Then find out what format it will be in on the day the card stops working.