Penpot vs Figma: Post-Adobe-Acquisition Reality Check

The Adobe acquisition of Figma fell apart in late 2023, and for about six months after that, every design-tooling conversation we had with clients started with the same question. Should we be moving off Figma. The Adobe deal was the catalyst, but the real driver was something more durable: design teams had quietly built their entire workflow on a single proprietary SaaS, and the near-acquisition exposed how exposed that bet was.

Two and a half years later, that question has gotten more interesting, not less. Figma raised, went public, kept shipping, and quietly raised prices on its mid-tier plans. Penpot kept shipping too, and crossed enough of a feature threshold that it stopped being a curiosity and started being a real option for specific kinds of teams. The Penpot vs Figma conversation in 2026 is no longer about ideology. It is about which teams are actually structured to benefit from an open source design tool, and which teams will burn more in friction than they save in license fees.

This post is the framework we use when a design lead, a head of product, or a CTO asks whether their team should evaluate Penpot as a Figma alternative. We have run pilot migrations in both directions. We have also told clients to stay on Figma when the migration math did not work. Both calls were correct in the moments they were made.

What changed since the failed acquisition

The failed Adobe deal mattered less than people thought it would. Figma stayed independent, kept its design team, and continued shipping at roughly the same pace. The bigger changes since 2023 have been on the business side. Figma went public in 2025, the Dev Mode product matured into a paid tier on its own, the Figma Slides and FigJam expansions reframed the product as a design platform rather than a single tool, and pricing across all tiers crept up. A full seat with Dev Mode now runs in the $30 to $45 per month range on annual billing, depending on plan mix and seat type.

Penpot in 2026 is a different product than it was in 2023. The 2.0 release brought CSS-aligned design tokens, flex layout that maps cleanly to web layout primitives, and a components system that finally feels usable for real design systems rather than a prototype. The self-hosted story matured. The cloud-hosted Penpot service is free for teams of any size, which is the single biggest commercial difference from Figma and the part that most often gets oversimplified in comparison posts.

Free does not mean cheap. The total cost of a design tool is license fees plus migration friction plus dev handoff overhead plus the time your team loses fighting the tool. Penpot's license cost is zero. Its other costs are real and have to be measured before you can compare apples to apples.

The other thing that changed: dev handoff stopped being optional. In 2023 you could ship a design team on Figma and the developers would muddle through. In 2026 most product orgs have formal handoff tooling, design tokens piped into the codebase, and CI checks against the design system. That raised the stakes on any design tool migration. Breaking dev handoff for a quarter is now a real cost in shipped features, not just a friction line item.

The honest feature gap

Figma is still the more polished product on most surfaces. The canvas performance on files with thousands of layers is better. The auto-layout system has more edge cases handled, especially around mixed-direction nesting and conditional sizing. The component variant system, with its property-based switching, is more mature. The plugin ecosystem is dramatically larger, with hundreds of well-maintained plugins for icon imports, content generation, accessibility checks, and CRM data hooks. FigJam for whiteboarding is a real product. Figma Slides is rough but exists.

Penpot's strength is in a different shape. It uses real web standards under the hood. Components export as CSS-aligned structures. Design tokens are first-class and W3C draft compliant. The flex layout produces flex CSS that a developer can read in the inspector and recognize. The file format is open and inspectable, which sounds like a small thing until you have tried to do programmatic operations on a Figma file and discovered how much friction the proprietary format adds. Penpot's API and the export pipeline are the practical wins.

The gaps that matter for most teams: plugin ecosystem, canvas performance on very large files, prototyping fidelity (Figma's transitions and interactions still feel smoother), variable fonts and advanced typography (Figma handles edge cases that Penpot still trips on), and real-time multiplayer (Penpot's multiplayer works but feels less smooth than Figma's, especially on slower connections). None of these are dealbreakers for most teams, but they accumulate into a different daily experience.

The gaps that do not matter as much as people think: Dev Mode and code export. Penpot's inspector exports cleaner CSS than Figma's by default because the underlying primitives match web standards more closely. Teams that rely heavily on Figma Dev Mode for handoff often find Penpot's handoff surface actually closer to what their developers want. This was a surprise to us the first time we ran it on a real codebase, and it has held up across the implementations we have done since.

The gaps that matter for some teams specifically: vector tools for marketing and brand work (Figma is more capable, though both lag dedicated illustration tools like Affinity Designer or Adobe Illustrator), and integration with research tools like Maze, UserTesting, and Lookback (Figma has the deeper integrations because the ecosystem is larger). If your design team is heavily research-driven and the research tooling sits in Figma, that integration cost is real.

Where Penpot actually wins

• Cost at scale. Penpot cloud is free for any team size. Self-hosted Penpot has infrastructure cost but no per-seat tax. For an org with 50 designers and 200 developers on viewer seats, the annual difference versus Figma can run $80,000 to $150,000.
• Open file format. Penpot files are inspectable and scriptable. If your design ops team does programmatic operations on files (bulk renaming, token audits, automated accessibility checks, component usage reports), Penpot makes this an order of magnitude easier than Figma.
• Self-hosting and data residency. If your design system, brand assets, or in-progress product designs need to stay on your own infrastructure (regulated industries, government contracts, sensitive product work), Penpot is the only real option with feature parity.
• Web-standard primitives. Layout, tokens, and components map cleanly to web standards. Dev handoff produces CSS that looks like CSS, not Figma-isms translated to CSS.
• No vendor lock-in pressure. You own the files, you can self-host, you can fork the codebase if a critical bug ships in a release. None of those options exist on Figma at any price.

Where Figma actually wins

• Plugin ecosystem. Hundreds of mature plugins versus a smaller (though growing) Penpot plugin set. If your workflow depends on specific plugins, audit the migration before committing.
• Canvas performance on huge files. Figma still handles 5,000-layer files better than Penpot. Most teams do not have files that large, but if you do, this is real.
• Prototyping fidelity. Figma's interaction model handles complex prototypes (multi-state, scroll-based interactions, smart animate) more cleanly than Penpot's current build.
• Variant systems and complex components. Figma's variant property model is more mature for design systems with hundreds of components and dense permutations.
• Research and team-collab ecosystem. Figma's integrations with Maze, UserTesting, Notion, Linear, Jira, and Slack are deeper than Penpot's current state.
• Hiring and onboarding. The market of designers who already know Figma is far larger than the market that already knows Penpot. New hires will be productive faster on Figma.

When team size makes Penpot viable

Team size matters less than team composition, but size sets the cost math, so it is the right place to start. Three rough bands cover most of the teams we have evaluated.

Under 10 designers, simple product surface, no compliance pressure. The migration cost is not worth it. Figma's polish and ecosystem outweigh Penpot's cost advantage at this scale, because the absolute dollar savings are modest and the friction of switching is concentrated on a small team that cannot absorb the disruption easily. Stay on Figma. Revisit if the team grows or the workflow gets more programmatic.

10 to 50 designers, mid-size product org, mixed handoff complexity. This is the band where the choice gets interesting. Figma costs add up to $5,000 to $25,000 per year depending on seat mix and plan. Penpot is free on cloud, or $4,000 to $10,000 per year self-hosted including infrastructure and ops time. The cost savings exist but are not the deciding factor. The deciding factor is whether your team's workflow is plugin-heavy, prototype-heavy, and research-tool-heavy, or whether it is token-heavy, dev-handoff-heavy, and design-ops-heavy. The first archetype stays on Figma. The second archetype is a real Penpot candidate.

50+ designers, large enterprise, complex handoff, or regulated data. The cost math starts to win on its own, often $50,000 to $200,000 per year in license savings. The compliance posture (self-hosting for regulated data) is sometimes a separate driver that makes the choice for you. At this scale, the migration cost is real (often $100,000 to $300,000 in design ops, training, and parallel-running time) but the payback is typically inside two years. The decision becomes operational rather than financial: does your design ops team have the capacity to drive a migration cleanly, and can you absorb a quarter of slowed velocity during transition.

The pattern is consistent. Penpot wins on cost only when the cost is large enough to absorb the migration. That floor sits higher than most posts suggest. We rarely recommend the migration for teams under 15 designers unless there is a specific non-cost driver (compliance, programmatic design ops, deep dev handoff alignment).

The other angle: design tokens and dev pipeline alignment

Some of the strongest Penpot cases we have seen had nothing to do with cost. They had to do with whether the design tool aligned with the dev pipeline. Teams that have invested heavily in design tokens, Storybook-driven component development, and automated handoff (Style Dictionary, Tokens Studio, custom token sync scripts) often find Penpot's web-standard primitives easier to integrate than Figma's proprietary token system.

This is the part that surprises people. Figma added Variables in 2023 and has improved the token story since, but the mapping from Figma Variables to CSS variables or to a design token spec still requires translation. Penpot's tokens are draft W3C spec by default. The sync into your codebase is more direct, the round-trip auditing is cleaner, and the design-to-code drift is smaller.

For a team where design and code share a tight loop (component library lives in code, designers consume it in the design tool, changes flow both ways through tokens), Penpot can simplify the pipeline. For a team where design and code are loosely coupled (designs are reference, developers re-implement them, tokens are a spreadsheet at best), the alignment benefit is theoretical and the migration is not worth it. Audit the actual pipeline before assuming this benefit applies.

The honest counterpoint: Figma's plugin ecosystem includes plugins that bridge the same gap (Tokens Studio, Specify, custom Style Dictionary exporters). These work well for teams that have built around them. Switching off them to use Penpot's native flow is a real disruption, even when the destination is technically cleaner. The right answer depends on whether your current Figma token flow is working or fighting you.

The self-hosting question

Self-hosting Penpot is not free, but it is not heavy. A reasonable production deployment runs on a small Postgres instance, a Redis cache, a Penpot frontend container, a backend container, and a file storage volume. On AWS or DigitalOcean, that runs $80 to $250 per month depending on team size and concurrent usage. Ops time runs 2 to 6 hours per month for upgrades, backups, and monitoring.

The break-even on self-hosting versus Penpot cloud is operational, not financial, because Penpot cloud is free. You self-host Penpot when you need data residency, when you need to integrate with internal authentication (SSO via your own identity provider), when you want to fork or customize the build, or when you have compliance contracts that require it. Cost is not the driver because cloud is already zero.

The honest tradeoff: self-hosting introduces an upgrade cadence and an operational responsibility your design ops team probably has not had before. Penpot upgrades are usually clean but occasionally introduce migrations that need attention. Backups need to actually work. A self-hosted design tool that goes down on a Tuesday morning blocks the entire design team. Treat it as production infrastructure or use the hosted version.

For teams that already run self-hosted infrastructure for other tools (GitLab, Sentry, internal apps), Penpot fits the existing operating model. For teams whose only self-hosted thing would be Penpot, the cloud version is the right starting point. Move to self-hosted only when a specific driver requires it.

A migration playbook that does not break dev handoff

The migrations we have seen go badly all shared one mistake: they tried to flip the entire design team at once, mid-quarter, while shipping product. The migrations that went well took longer and felt slower but actually completed.

Phase 1: Component library port (4 to 8 weeks). Pick one designer (often a design system maintainer) and rebuild the core component library in Penpot. Do not migrate; rebuild. The point is to redesign the system around Penpot's primitives rather than translating Figma idioms. Run this in parallel with the existing Figma library. At the end of this phase, you should have a Penpot library that produces the same visual output as the Figma library, but built natively.

Phase 2: New work pilot (6 to 12 weeks). Move new projects onto Penpot. Keep existing projects on Figma. This isolates risk: if Penpot creates friction on a new project, you have not broken any in-flight work. Track the pain points carefully. The pilot is also a chance for developers to start consuming Penpot inspector output and adjusting handoff conventions. Capture every workflow break in a shared doc. Most of them turn out to be habitual rather than fundamental.

Phase 3: Targeted file migration (3 to 6 months). Migrate active projects in priority order, starting with the simplest. Use Penpot's Figma import where it works, but expect to rebuild complex files manually. Some Figma files (highly variant-driven, plugin-dependent, deeply prototyped) will not import cleanly. Decide per-file whether to rebuild or to keep frozen on Figma indefinitely as reference. Both are valid moves.

Phase 4: Token and CI integration (overlapping with Phase 3). Wire Penpot tokens into the codebase. Update Storybook integrations and design system docs. Run automated diff tools against the previous Figma-driven token export to catch drift. This phase pays back across every future feature, but it is the one that tends to get cut for time. Do not cut it.

Phase 5: Sunset Figma (6 to 12 months from start). Cancel Figma seats progressively as files migrate. Keep a small number of viewer seats for archive access during the first 6 to 12 months post-migration. We have seen teams over-commit to a clean cutover and then scramble when a developer needs to reference an archived file. The transition costs $200 to $500 per month in retained Figma seats and saves much more in ops chaos.

The total migration time on a mid-size org is usually 9 to 15 months end to end. Teams that try to compress this into a quarter consistently regret it. The slower path is also cheaper, because design velocity stays mostly intact through the transition rather than dropping 30 to 50 percent for a single quarter.

What we tell design and dev leads when they ask

The first question we ask is what the team's relationship with plugins looks like. If a single critical workflow depends on a Figma plugin that has no Penpot equivalent, the migration math gets worse fast. Plugin replacement is the single most common cause of post-migration regret. Inventory the plugins your team actually uses (not the ones it has installed) before committing to any move.

The second question is how the developers consume designs. If developers live in Dev Mode, copy CSS out of the inspector, and rely on Figma's measurement tools, Penpot's handoff surface is usually competitive or better. If developers consume designs through Storybook with token-driven components, the design tool barely matters and Penpot's cleaner token pipeline is a real edge. If developers do not consume designs at all and just look at screenshots, the design tool choice is purely a design team decision and the dev pipeline argument does not apply.

The third question is whether anyone on the team will actually drive the migration. A Figma to Penpot move needs a project owner who can rebuild the component library, run the pilot, and shepherd the team through a quarter of awkwardness. Teams that nominate a champion succeed. Teams that hope the migration will run itself almost always stall in Phase 1 and revert to Figma with a soured team morale.

The wrong reason to move to Penpot: "Figma got expensive." Figma is expensive in absolute dollars at scale, but the relative cost as a fraction of design team salary is small. License fees rarely justify the migration cost on their own. The right reasons: your design ops workflow is programmatic and the open file format unlocks real automation, your team has tight design-code alignment that benefits from web-standard primitives, your compliance posture requires self-hosting, or your seat count is large enough that the license savings cross $50,000 per year and you have the ops capacity to execute the migration cleanly.

The wrong reason to stay on Figma: "Penpot is not ready." Penpot was not ready in 2023. It is ready in 2026 for a real set of use cases. The question is whether your team is one of those use cases. Saying "not ready" without auditing the actual fit is reflex, not analysis. Run a pilot on a real project before deciding.

Figma is not legacy. Penpot is not the future by default. They are two different tools optimized for two different operating models. Figma is a polished, plugin-rich, ecosystem-heavy SaaS design platform. Penpot is an open, web-standard-aligned, self-hostable design tool that rewards teams with tight design ops and dev pipeline discipline. Pick the one whose operating model matches yours, not the one whose narrative matches your aesthetic.