Figma vs Penpot for design teams in 2026: feature parity and self-host

Penpot crossed a threshold in late 2024 that mattered. Components got nested overrides. Flex layout shipped and worked. Design tokens became a first-class concept, not a plugin. For the first time, you could open Penpot, build a real component library, and ship it to a small team without the workflow falling apart by Friday.

That doesn’t mean Penpot replaces Figma for everyone. It means the cost of evaluating a replacement dropped from “this will eat a quarter” to “we can pilot it on one feature this sprint.” And with Figma’s 2025 pricing restructure still settling into renewal cycles, more design leads are running that pilot than were a year ago.

This is what we found after spending a week on each tool with the same three test projects: a mobile checkout flow, a small design system migration, and a developer handoff exercise.

Where Penpot caught up — and where it still hasn’t

Penpot 2.0 closed the gap on the workflow primitives that used to make it a non-starter for production teams:

• Flex layout — equivalent to Figma’s auto-layout for most cases. Direction, alignment, gap, padding, wrap. Works on nested groups. The interaction model is slightly different (Penpot leans on CSS terminology where Figma invented its own), which is friendlier to engineers and slightly slower for designers coming from Figma muscle memory.
• Design tokens — Penpot ships tokens as native objects. You can define color, spacing, and typography tokens and bind them to components. Export goes to the W3C Design Tokens format, which means Style Dictionary and other token pipelines work without conversion.
• Component variants — variants with typed properties (boolean, instance swap, text) are supported. Naming conventions differ; behavior is close enough that a designer can rebuild a small system in a day or two.
• Plugin API — Penpot opened a plugin API in 2024. The ecosystem is small. Figma still wins by an order of magnitude on plugin count, and that gap will not close in 2026.

Where Figma is still ahead, measurably:

• Dev Mode — Figma’s Dev Mode (with Code Connect, status flags, measurements, code snippets) is more polished. Penpot’s inspect tab covers the basics; it does not have a Code Connect equivalent yet.
• FigJam-style whiteboarding — Penpot’s canvas can be used for diagramming but there’s no dedicated whiteboard product. If your team relies on FigJam for sprint rituals, you’d need a separate tool.
• Library marketplace — Figma Community is enormous. Penpot has a starter set of shared libraries; you’ll build most of your own.
• Real-time collaboration polish — multi-cursor and live editing work in both. Figma is faster and more predictable on documents with hundreds of frames.

The self-host math

This is where the comparison stops being about features and starts being about money plus operational risk.

Figma’s 2025 pricing changes raised the per-editor cost for full design seats and split some collaborative features into higher tiers. The Dev Mode add-on is a separate per-seat line. For a 20-designer team, you’re looking at roughly $4,000–6,000/year just for design seats, before viewers and Dev Mode are layered in.

Penpot self-hosted has a different cost profile:

• Software: $0 (MPL 2.0)
• Infrastructure: a Docker Compose deployment runs comfortably on a $40/month VPS for small teams. Bigger teams want managed Postgres, Redis, and object storage — call it $150–300/month for a 50-person org on reasonable cloud infrastructure.
• Operational overhead: someone on your team has to own backups, upgrades, and uptime. This is the line item most teams underestimate. Budget half a day per month minimum, more during major version upgrades.

The break-even point sits around 10–15 active designers on most clouds. Below that, Penpot Cloud (the hosted SaaS version, currently free with a paid plan in beta) makes more sense than rolling your own. Above that, self-hosting starts paying for itself within the first year — if you have someone to operate it.

What migration actually looks like

We tried importing a small Figma library (40 components, 80 tokens) into Penpot. Realistic findings:

1. There is no native Figma → Penpot import. A community plugin exists; it handles flat shapes and basic frames. It does not preserve auto-layout to flex layout cleanly, nor variants to variants. Plan to rebuild your component library by hand.
2. Tokens transfer better than components. If your tokens are already in W3C format or Style Dictionary, you can import them with minimal cleanup.
3. Dev handoff workflows need re-wiring. Any tooling pointed at Figma’s API (Storybook integration, Zeroheight, automated PR comments with screenshots) needs new connectors. Penpot has a REST API; most of the third-party glue does not exist yet.

For most teams, the realistic path is coexistence — run Penpot on new projects or a single feature team, keep Figma for the existing design system until parity in your tooling catches up. A hard cutover for a 20-designer org is a multi-quarter project, not a sprint goal.