Which Figma alternative fits your team: Figma or self-hosted Penpot
If your renewal is driven by seat costs or your organization needs design files on its own servers, self-hosted Penpot is the option to evaluate first. If your team depends on Figma's Dev Mode, its mature prototyping and a large library of community plugins, staying on Figma and negotiating the terms is usually the lower-risk path for now. The decision turns on four questions: where design data must physically live, how much of your current workflow depends on Figma-only features, whether your platform team already runs PostgreSQL and S3-compatible object storage, and how much operational ownership you want to take on. Start with data location. Figma's data residency is available only on the Enterprise plan, and its help center notes that comments, file names, plugins, fonts and preview thumbnails are not hosted in the chosen region, so confirm that gap with your legal and security teams before you assume regional hosting covers everything. Penpot's cloud plans and self-hosting are separate choices: the cloud pricing page lists plans that Kaleidos operates, while a self-hosted instance runs in the data center or cloud account you select. Ask your compliance lead which of those two models satisfies the requirement, and whether an on-premises instance changes the answer. Next, map your workflow dependencies. Penpot's Figma exporter plugin converts files into a .zip that Penpot can import, but it does not carry prototyping settings, so teams that rely on Figma prototypes should test a sample of their prototypes before committing. Penpot's SVG, CSS, HTML and JSON foundation and native design tokens suit developer handoff, yet the Dev Mode features you use daily may not have a direct equivalent, so list them and check each one. Finally, weigh operations: self-hosting Penpot means you own upgrades, backups and the PostgreSQL 13 or later and Valkey dependencies, which DeployOpen can plan, deploy and support in your environment if you prefer not to run them alone.
Which scenarios favor Figma and which favor Penpot
This table matches common product design scenarios to the platform that usually fits them better. Read each row as a condition check: if the stated condition holds in your organization, that option is the stronger starting point. Figma keeps the lead where Dev Mode handoff, prototyping and its plugin ecosystem are central to daily work. Penpot leads where residency, air-gapped operation, open formats or self-hosting are firm requirements.
| Scenario | Better fit | Condition that makes it true |
|---|---|---|
| Heavy Dev Mode handoff | Figma | Developers rely daily on Dev Mode specs, measurements and code snippets. Confirm Penpot's handoff covers your workflow before moving. |
| Reliance on Figma plugins | Figma | Your team depends on specific Community plugins with no Penpot equivalent. Check each plugin against Penpot's plugin system and open API. |
| Strict residency for files and comments | Penpot | Policy requires design files, comments and accounts to stay in your own data center. Figma's regional hosting needs Enterprise and excludes comments. |
| Air-gapped design work | Penpot | Designers cannot reach cloud tools. Penpot runs in a closed network with PostgreSQL, Valkey and object storage deployed alongside it. |
| Need for open file formats | Penpot | You want design data in SVG, CSS, HTML and JSON. Figma's local copies are proprietary .fig, .jam or .deck files. |
| Heavy prototyping and flows | Figma | Interactive prototypes drive reviews. The Figma exporter plugin does not carry prototyping settings into Penpot. |
| Small team with limited platform staff | Figma | No one can run and patch PostgreSQL, Valkey, storage and backups. Penpot's hosted plans are an option if self-hosting is not staffed. |
Where design files, comments and accounts live under each option
Figma stores design files in its own cloud. Its data residency solution, which Figma calls localized file hosting, is available only on the Enterprise plan, and it lets an organization choose the region where files are hosted. The region does not cover everything, so teams with a residency requirement need the full list of exclusions before they sign.
- Plan requirement: Localized file hosting is limited to the Enterprise plan, so a residency requirement on any other plan cannot be met with this setting.
- Items outside the region: Comments, file names, plugins, fonts and preview thumbnails are not hosted in the chosen region.
- Other data classes: Ask Figma in writing whether activity logs, version history and account records follow the chosen region.
- Local copies: Local .fig, .jam and .deck files live on the user's device, outside Figma's hosting, and carry no version history or comments.
Check the Figma help article on localized file hosting against the current contract, and ask for the list of data classes outside the region before accepting any residency statement.
Penpot offers a hosted service through several plans, listed on its pricing page as read in October 2026. The plan decides the commercial terms and the operating model, so hosting location, operator and sub-processors are questions to settle with Penpot before any design files move into the hosted service.
- Plan range: The pricing page lists Professional, Unlimited, Enterprise and a Private Server option, each with different terms and limits.
- Private Server: This option is the closest hosted model to a dedicated instance. Confirm where it runs, who operates it and who holds administrative access.
- Hosting region: The supplied information does not name hosting regions for Penpot's cloud plans, so ask which regions store files, comments, thumbnails and account records.
- Sub-processors: Request the current list of sub-processors and the countries where each one processes data.
- Exit terms: Confirm the export formats and the process for getting files and comments out if the service ends.
Review the Penpot pricing page for plan terms, then get the hosting location, operator and data classes in writing, because the pricing page does not answer those questions.
Self-hosted Penpot runs in the organization's own data center or cloud account, so design files, comments, thumbnails and accounts stay in the environment the team deploys. Penpot documents Docker Compose, an official Helm chart and several platform options, and the team chooses the storage components that match its controls.
- Database: Penpot supports only PostgreSQL, with version 13 or later recommended, so file metadata and comments are kept in a database the team operates.
- Notification coordination: Penpot uses Valkey to coordinate websocket notifications, so this component is part of the production stack and needs its own availability and access controls.
- Uploaded objects: Files can be stored on the filesystem or in S3-compatible storage such as MinIO, and the team controls where those objects sit and how they are encrypted.
- Deployment platform: Penpot documents Docker Compose, the official Helm chart, OpenShift, Rancher, Elestio and TrueNAS, so pick the one that matches existing platform standards.
- Backups: The team owns backup and restore for PostgreSQL and object storage. Back up both on a consistent schedule so files and their records stay in step.
Start from the Penpot getting started guide and confirm storage location, backup scope and encryption at rest and in transit for every component, because the team operates each layer in this model.
Self-hosted Penpot can authenticate users with its own email and password accounts or with external identity sources. Penpot documents Google, GitHub and GitLab OAuth, generic OpenID Connect for single sign-on and LDAP, so account records and sign-in can be governed through the organization's existing identity provider.
- Default login: Email and password is enabled by default, so decide whether it stays on for production users once single sign-on is in place.
- Social OAuth: Google, GitHub and GitLab OAuth send authentication to those external providers, which the security team should approve as part of its supplier review.
- OpenID Connect: Generic OIDC connects Penpot to a corporate identity provider for single sign-on, so claim mapping and group handling must be agreed in advance.
- LDAP: LDAP connects Penpot to a directory service, so confirm how accounts are created, changed and disabled when staff move or leave.
- Provider controls: Confirm multi-factor enforcement, session lifetimes and deprovisioning at the identity provider, since Penpot's own settings do not show what the directory enforces.
Review the Penpot configuration reference and test deprovisioning and multi-factor enforcement with the identity provider before go-live.
Where data sits is only one part of an assessment. Under any hosting model, the team prepares the evidence: configuration records, access reviews, backup restore tests and data flow descriptions. Independent auditors and certification bodies assess that evidence, and DeployOpen prepares systems, controls and evidence for those assessments without issuing reports or attestations.
- Hosting records: Keep the region, operator and sub-processor records for Figma, for a Penpot cloud plan or for a self-hosted environment.
- Access records: Export user lists, login methods and administrative roles at set intervals and keep the results with the change record.
- Restore evidence: Record restore tests for PostgreSQL and object storage, including the date and the scope of data restored.
- Vendor documents: Store Figma's residency article and the Penpot plan terms with the contract file, dated as read.
- Assessor scope: Confirm with the assessor which standards or regulations apply and how they treat cloud records compared with self-hosted records.
Ask your assessor early which evidence they expect for each hosting model, since the evidence list for a vendor-run cloud differs from the list for a stack the team operates.
What you pay for in Figma and what you run with Penpot
Figma's cost is a recurring subscription built from seats, and the seat types and plan tiers you buy decide the total. Figma sells Full, Dev and Collab seats across its Professional, Organization and Enterprise plans, so the first step is counting how many people edit, how many only inspect handoff specs, and how many only comment in shared files. Data residency is the item most likely to change the plan. Figma's localized file hosting is available only on the Enterprise plan, and comments, file names, plugins, fonts and preview thumbnails stay outside the chosen region. Ask the Figma account team for a written quote that lists seats by type, the plan tier, and whether residency is priced as part of Enterprise, and confirm which of your data types it covers.
Self-hosted Penpot has no license fee, so your costs are infrastructure and people. The core stack is PostgreSQL 13 or later, Valkey for websocket notification coordination, and file storage on the local filesystem or an S3-compatible service such as MinIO. You pay for the servers or cloud accounts that run these components, for backups and their retention, and for the staff who install, patch and upgrade the platform. Setup and the library migration are one-time costs. Hosting, storage growth, backup copies and the time spent on each upgrade recur. The main drivers are the number of concurrent editors, the size and count of design files, how long you keep backups, and whether you need high availability. The Penpot technical guide on configuration lists the settings that affect this stack.
If you compare against Penpot's hosted offer, the Penpot pricing page listed Professional at $0, Unlimited at $7 per editor per month capped at $175 per month, Enterprise at $25 per member per month, and a Private Server at $50k per year, as read in October 2026. Those figures change, so check them on the day you decide. When you request quotes, ask Penpot or a hosting partner for the same details: the number of editors, expected file volume, storage growth per year, backup and restore targets, support hours, and what an upgrade costs in staff time. If you use DeployOpen for implementation, the scope, deliverables and timeline are agreed in writing before work starts, and the quote follows from that scope.
Cost components on each side and what drives them
Figma charges per seat on a commercial plan, while self-hosted Penpot carries no license fee but moves cost into infrastructure, database operations, identity integration and staff time. The cards below separate one-time work from recurring spend on each side, and list what to request in a written scope before comparing totals.
Licensing and seat fees
Figma's cost is recurring and scales with the number of paid seats and the plan tier, including Enterprise features such as the data residency option. Penpot's self-hosted edition has no license fee under MPL-2.0, but Penpot's cloud plans, shown on its pricing page as read in October 2026, are a separate option with per-editor and per-member pricing. Ask Figma for a seat count by role and the Enterprise features you need, and decide early whether Penpot cloud, a Penpot Private Server or a self-hosted instance fits your budget.
Infrastructure hosting
Self-hosting Penpot is a recurring cost for compute, networking, backups and monitoring in your own cloud account or data center. Costs rise with concurrent editors, the number of large files and high availability requirements, and fall when you consolidate environments. Request a sizing estimate from your platform team that covers application nodes, load balancing for websocket traffic, and separate production and staging instances.
Database and storage operations
Penpot runs only on PostgreSQL, with version 13 or later recommended, and uses Valkey for websocket notification coordination. Uploaded objects go to the filesystem or to an S3-compatible store such as MinIO. These components need backups, patching, capacity planning and restore tests, which are recurring tasks for your database and storage staff. Ask for a written backup and restore procedure and a storage growth forecast based on your current Figma library size.
Identity integration
Figma uses its own account model with SSO and SCIM on Enterprise plans. Self-hosted Penpot supports email and password login by default, plus Google, GitHub and GitLab OAuth, generic OpenID Connect and LDAP. Connecting Penpot to your existing directory is a one-time integration task, but group mapping, role changes and offboarding become recurring operations you must own. Confirm which identity provider you will use and whether group sync is in scope.
Staff and upgrade effort
Staff time is the largest recurring cost in a self-hosted model. Someone must apply Penpot releases, test them against your PostgreSQL and identity setup, and handle incidents, which Figma absorbs in its subscription. The release cadence is visible in the project's GitHub releases, where 2.18.3 followed 2.18.2 and 2.18.1 in early October 2026. Ask for a named owner, an upgrade runbook and a support model, whether internal or through a retainer.
One-time migration work
Moving files is a one-time cost. Penpot's Figma exporter plugin converts files to a .zip for import but does not carry prototyping settings, so designers will rebuild those by hand. Effort grows with the number of libraries, components, variants and auto layout usage, and with file size. Ask for a file inventory, a pilot with representative files, a fidelity check list and a plan for rebuilding prototypes, and budget that work separately from running costs.
What a move from Figma to Penpot involves at a high level
The sequence turns a Figma estate into a verified Penpot workspace, with each stage closed by a check that the team can sign off before the next one starts. It shows where the work sits, what the plugin does and does not carry, and what has to be kept.
Inventory files, libraries and plugins
The design lead lists the Figma teams, projects, shared libraries, component sets, and any plugins the team relies on, and marks which files are active and which are archives. Engineering confirms which plugins have a Penpot equivalent and which need a different workflow. The output is a written inventory with an owner for each file and a decision on what moves, so nobody discovers a missing library during cutover.
Stand up the Penpot instance
The platform team deploys Penpot inside the organization's infrastructure using the documented Docker Compose or Helm paths, with PostgreSQL 13 or later, Valkey for websocket coordination, and filesystem or S3-compatible storage such as MinIO for uploaded objects. Identity is set up in parallel, using email and password, an OAuth provider, generic OpenID Connect or LDAP, as the organization requires. The check is a working login for a pilot group and a restore test of the database and object storage.
Export files with the Penpot Figma exporter
A designer runs the penpot-exporter-figma-plugin, maintained by Kaleidos under MPL-2.0, on each file in the inventory. The plugin converts the Figma file into a .zip that Penpot can import. Prototyping settings are not carried over, so the team records any flows or interactions that must be rebuilt by hand. The output is one archive per file, named and logged against the inventory.
Test imports of large files
Before any production import, the team imports the largest and most complex files into a staging Penpot instance and measures how long the import takes and whether it completes. Results are logged per file, including any failures, so the team can decide whether a large file should be split, cleaned up, or imported in a separate run. The check is a clean import log for every file in the test set.
Check fidelity of components and layout
A designer and a front-end engineer compare each imported file against the Figma original, checking components, variants, auto layout, text styles and fonts, and the shared libraries that depend on them. Mismatches are logged with the file, the element and the expected result, then fixed in Penpot or rebuilt. The check is a signed-off fidelity list in which every open item has an owner, and the team confirms what converts and what does not before the cutover.
Cut over teams and handoff
The organization moves teams to Penpot in agreed waves, with the library owners publishing their shared libraries first so dependent files resolve correctly. Designers and developers are told which Figma files are frozen and where the live versions now sit. The output is a cutover record showing the date each team moved and the files they now own in Penpot.
Retain exported copies under policy
The security or records owner decides how long the exported Figma copies, local .fig, .jam or .deck files, and the Penpot archives are kept, and where they are stored and who can read them. Access to these copies is reviewed against the organization's retention policy. The closing check is a retention record that names each archive set, its location and its review date.
Questions buyers ask before moving from Figma to Penpot
How much does a move from Figma to self-hosted Penpot cost?
Penpot itself carries no license fee under the Mozilla Public License 2.0, so the cost is the infrastructure you run plus the people who install, migrate and operate it. Infrastructure covers servers or cluster capacity, PostgreSQL, Valkey and file storage, which can be on the filesystem or S3-compatible storage such as MinIO. Labor covers platform setup, identity integration, migration of files and libraries, and testing. Most of these costs recur as hosting and maintenance, while setup and migration are largely one-time. Costs rise with the number of files, team size, backup requirements and the number of environments you keep. Ask any provider, including DeployOpen, for a written scope that lists each component so you can compare it with your current Figma seat spend.
How long does migrating Figma files to Penpot take?
The timeline depends mainly on the volume and complexity of your files, how many libraries you have, and how much of the design system you need to verify after import. The Penpot Figma exporter plugin converts files into a .zip that Penpot can import, so teams with many large files will spend more time on batch exports, import runs and visual checks. Prototyping settings do not convert, so any flow that depends on them needs rebuilding. Your platform setup, identity integration and internal review windows also affect the schedule. Ask for a timeline tied to a file inventory, and agree on acceptance checks in the written scope before work starts.
Can our internal team self-host Penpot, or do we need outside help?
A team with container and database operations experience can deploy Penpot, since the project documents Docker Compose and an official Helm chart, along with OpenShift, Rancher, Elestio and TrueNAS. Teams without that experience usually bring in help for the first deployment, hardening, backups and upgrades, then keep operations in house. The decision depends on whether you already run Kubernetes or Docker hosts, who owns on-call duties, and how fast you need production ready. DeployOpen plans, implements, hardens, backs up, upgrades and documents self-hosted platforms inside your own environment, and that support can be fixed-scope or ongoing through a retainer.
What skills does our staff need to run self-hosted Penpot?
Operating Penpot requires three core skills. The first is PostgreSQL administration, since Penpot supports only PostgreSQL and recommends version 13 or later. The second is container or Helm operations, for the Docker Compose or Kubernetes deployment, upgrades and rollback. The third is identity configuration, because self-hosted Penpot supports email and password login by default, plus Google, GitHub and GitLab OAuth, generic OpenID Connect and LDAP. Your team will also need to manage Valkey for websocket notification coordination and the filesystem or S3-compatible store for uploaded objects. Assess these skills honestly against your roster before you commit to a date.
Can we replace Figma Dev Mode features in Penpot?
Penpot covers much of developer handoff through open standards: designs are built on SVG, CSS, HTML and JSON, it has native design tokens, and it offers an open API and plugin system. Some Dev Mode conveniences, such as the exact inspection workflow, code snippets and integrations your developers rely on, may have no direct equivalent and may need plugins or a change to how engineers work. List the Dev Mode features your engineers use every day and test each one against a sample file during scoping. Our separate handoff page covers which features map and which do not.
What happens to our existing libraries, components and comments?
Components, variants, auto layout, libraries and text are the elements the migration path is designed to carry over, but you must verify each on your own files after import. Prototyping settings do not convert and need to be rebuilt. Comments are a separate question: Figma's local copy formats, .fig, .jam and .deck, do not include version history or comments, so do not assume comment threads will move with the design files. Plan to export comment content separately if the discussion matters, and record which libraries are published and used by which teams before you start. Ask the implementer to document the fidelity checks in the written scope.
How do we keep design files in a specific region with Penpot?
Self-hosting puts the instance, its PostgreSQL database and object storage in the data center and cloud account you choose, so design files and accounts stay where you place them. Figma's own data residency option is limited to its Enterprise plan, and its help center notes that comments, file names, plugins, fonts and preview thumbnails are not hosted in the chosen region. Confirm with your provider exactly which components run where, including backups, logs and any email or OAuth dependencies, and document that in your compliance evidence.
What to confirm with Penpot and your own environment before deciding
Start by confirming the current Penpot version and release cadence against the project's release notes on Penpot GitHub releases. Recent patch releases have been published within days of each other, so a version you test in a pilot may be superseded before rollout. Plan an upgrade routine and confirm how the team's chosen version is tested before it reaches production. Do not assume a feature from Figma exists in Penpot until you have checked it in the version you will run. In particular, verify prototyping behavior and any Dev Mode-style handoff workflows with your own designers and developers, because the Figma exporter does not carry prototyping settings and Penpot's developer handoff will not match Figma's feature for feature.
Next, test plugin compatibility for the workflows your team actually uses, not for the plugin count. List every Figma plugin in active use, then check whether an equivalent exists in Penpot's plugin system, whether it runs against your version, and whether it needs outbound network access that your environment may block. Confirm the identity provider settings with your identity team as well: self-hosted Penpot supports email and password, Google, GitHub and GitLab OAuth, generic OpenID Connect and LDAP, so decide which one governs access, how group membership maps to team roles, and how offboarding removes access to files. Document the answers before the pilot begins.
Size the storage backend and the database with the real file population, not an average. Penpot supports only PostgreSQL, recommends version 13 or later, uses Valkey for websocket notification coordination, and stores uploaded objects on the filesystem or in S3-compatible storage such as MinIO. Ask your platform team how each component is backed up and monitored. Then run a backup and restore test that restores the database and object store to a separate environment and opens a sample of large files, components and libraries. Finally, decide whether a Penpot cloud plan or self-hosting fits your residency rule. Penpot's pricing page lists cloud tiers, including a Private Server option, but confirm with the vendor where each tier stores data and whether it meets your region and contractual requirements. Self-hosting keeps the data in your own infrastructure, but it moves patching, backup and uptime work to your team or implementation partner.
How DeployOpen helps evaluate, implement or migrate to Penpot
DeployOpen is a Chainscore Labs company that plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure. For Figma vs Penpot, we work from a written scope so that the Penpot instance, its login setup and the design file move are agreed before any work starts.
How we scope
- Inventory which Figma teams, files, libraries and plugins the Penpot move must cover
- Agree whether Penpot runs in your cloud account, data center or air-gapped network
- Define login targets, such as OpenID Connect or LDAP, and who administers them
How we build
- Deploy Penpot with Docker Compose or the official Helm chart, backed by PostgreSQL 13 or later
- Configure Valkey for notifications and filesystem or S3-compatible storage for uploads
- Test Figma exporter output against a sample set of files and record fidelity gaps
How we hand over
- Deliver written runbooks for installation, upgrades, backups and restores of the database and objects
- Document the known migration gaps, including prototyping settings the exporter does not convert
- Walk your design, platform and security teams through access controls and admin tasks
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after handover
- Plan Penpot release upgrades and test them in a staging copy before production
- Confirm with your own team which support model fits your change and audit requirements
