For most product teams, the design tool is the one piece of the stack they do not own. Figma's per-seat pricing floor and proprietary binary format mean your most strategic assets — the actual visual definition of your product — live inside a vendor's cloud, in a format only that vendor can fully read. Penpot is the open-source answer to that, and it is a serious one: roughly 60,000 GitHub stars, backed by Kaleidos Inc., and built entirely on open web standards — SVG, CSS, and HTML — so your designs are human-readable, version-controllable, and portable without vendor permission. Penpot is MPL-2.0 licensed, which is the part almost everyone misreads. The Mozilla Public License is a file-level copyleft: if you modify Penpot's own source files, those files must stay open — but your design files (the SVG/CSS/JSON your team produces) are not infected, and can be proprietary, commercial, and closed. That is a fundamentally different risk profile from the AGPL, and it is the single most important license fact to understand before you adopt Penpot. This is a long, honest teardown of what Penpot is in 2026, how its open-standards model changes the lock-in math, the real split between what is free in self-hosting and what sits behind the Enterprise plan, what MPL actually demands, the operational reality of a Clojure-plus-Postgres-plus-Valkey stack, and precisely where your designs land.

1. What Penpot Is

Penpot is a web-based design and prototyping platform meant for cross-domain teams — designers and developers working together on the same product. It is positioned directly against Figma, Sketch, Adobe XD, and InVision. Unlike Figma's proprietary binary format, Penpot stores designs as standard SVGs, with CSS and JSON for the rest, making assets readable and version-controllable without vendor permission. It is built by Kaleidos Inc. (Spain/US jurisdiction) and is the primary open-source choice for product teams that want a design-to-code handoff workflow without Figma's per-seat licensing floor. It supports real-time collaboration, has a plugin API, and as of 2026 has added MCP (Model Context Protocol) server integration, bringing AI tooling into the design loop. The latest stable line is 2.17.x (v2.17.2, released August 27, 2026). The strategic pitch is sovereignty: MPL-2.0, GDPR-ready, fully self-hostable, and backed by open standards that guarantee design-asset portability independent of any vendor decision. For a team that treats its design files as core IP, that is the whole argument.

2. Open Web Standards: The Portability Guarantee

The reason Penpot matters more than "a free Figma" is its storage model. Figma keeps your designs in a proprietary format that only Figma can fully interpret. Penpot keeps them in SVG, CSS, and JSON — formats with公开的 specs, readable by browsers, editors, and your own tooling. That means:

• Assets are human-readable. You can open a Penpot design file's underlying shapes and styles without Penpot.
• Assets are version-controllable. Because they are text (SVG/JSON), they diff and merge like code.
• Assets are permanently accessible. No vendor can revoke your ability to read your own designs by changing a format.

For a sovereignty-focused operator, this is the design-world equivalent of Git-backed Markdown docs (see our Wiki.js piece): the format itself is the escape hatch. Even if Kaleidos disappeared tomorrow, your designs remain open. That is a stronger durability guarantee than any SLA.

3. The MPL-2.0 License — File-Level, Not Network

This is the section to read twice. Penpot is published under the Mozilla Public License 2.0. MPL is a weak copyleft with a file-level scope:

• If you modify Penpot's own source files (the .clj/.cljs files that make up the app), those modified files must be made available under MPL.
• Your design files — the SVG/CSS/JSON your team creates inside Penpot — are not derivative works of the Penpot source, so they are not subject to MPL. They can be proprietary, commercial, and closed.

This is fundamentally different from the AGPL (which Wiki.js uses). The AGPL's network clause would require you to release modified source if you offer a modified version as a network service. MPL has no such network clause at the file level: you can run a modified Penpot as a service, keep your modifications to the MPL-covered files open, and still keep your own designs and any separate proprietary tooling closed. For most self-hosters who run Penpot unmodified, MPL imposes essentially no obligation at all. The practical implication: if your business model is "host Penpot for clients," MPL is far friendlier than AGPL. You must open the Penpot files you change; you do not have to open your surrounding proprietary systems. That is why MPL is often called "the license that lets you build a business around the software without virally infecting your own IP."

4. The Free-vs-Paid Split in Self-Hosting

Here is the nuance that the "it's open source, so it's free" framing hides. Penpot's core is MPL-2.0 and free to self-host, but Kaleidos sells an Enterprise plan with features that are not in the self-hosted free tier. The split that matters for an operator:

• Free in self-hosting: OIDC, OAuth, and LDAP SSO; turnkey RBAC (Owner/Admin/Editor/Viewer roles); real-time collaboration; the full design and prototyping surface; the plugin API; MCP integration.
• Enterprise-gated or absent in self-hosted free: SAML and SCIM provisioning; audit-log legs; some compliance and administrative features.

So if your identity layer is OIDC/OAuth/LDAP (Keycloak, Authelia, or Authentik — all covered in this series), the free self-hosted tier covers you completely. If you specifically need SAML/SCIM from Penpot or detailed audit trails, you are looking at the paid plan. This is not a bait-and-switch in the malicious sense — the core is genuinely open — but it is a real scope line you must know before promising "full SAML" to your security team.

5. Architecture: Clojure, Postgres, Valkey

Penpot is a Clojure and ClojureScript full-stack application. The backend is Clojure on the JVM; the frontend is ClojureScript. State lives in PostgreSQL, and real-time collaboration and caching use Valkey (a Redis-compatible in-memory store). Deployment is via Docker Compose for a single node or Helm charts for Kubernetes. For an operator, the honest take is that this is a more exotic stack than the PHP of BookStack or the Node of Wiki.js. Clojure on the JVM means a different debugging vocabulary, JVM tuning familiarity helps at scale, and your usual "it's just Node" instincts do not apply. The upside is that the stack is mature and the project ships releases regularly (multiple per quarter in 2026). The downside is that when something breaks, the error logs are JVM/Clojure, not the stack you may know best.

6. Real-Time Collaboration

Penpot supports real-time multi-user editing — multiple designers and developers working on the same file with live presence. This is the feature that puts it in Figma's league, and it is included in the free self-hosted tier. Under the hood it relies on the Valkey-backed presence and the collaborative document model. For a team, this is the difference between "a design tool we tolerate" and "a design tool we actually share." The operational note: real-time collab means stateful, low-latency connections. Behind a reverse proxy (Caddy or Traefik, both covered here), you want WebSocket support and reasonable timeouts, because the collaboration channel is a long-lived connection, not a request-response. Get the proxy config right or you will see cursor lag and disconnects.

7. The Design-to-Code Workflow

Penpot's explicit job is the handoff between designers and developers. Because assets are SVG/CSS/JSON, a developer can inspect and reuse the actual values — colors as CSS variables, layouts as structures, components as definitions — rather than reverse-engineering a screenshot. The 2026 addition of MCP server integration pushes this further: AI tooling and external agents can read the design graph programmatically, turning a design file into a queryable source for code generation or documentation. For a team that wants "design is a first-class input to engineering," Penpot's open model is a structural advantage over a closed tool. The assets are already in a form your pipeline can consume. This is the workflow that justifies self-hosting it: the designs become part of your infrastructure, not a silo your build system cannot touch.

8. Plugin API and Extensibility

Penpot ships a plugin API (expanded across the 2.x line) and an MCP integration. Plugins let teams add exporters, validators, and custom panels without forking the core. Because the plugin boundary is supported by the project, extensibility does not require modifying MPL-covered source files — which keeps your extensions out of the copyleft scope entirely. That is a clean separation: customize via the supported plugin API, and your custom code stays yours. For a self-hoster, the guidance is the same as everywhere: prefer the supported extension point over forking. If you do fork a Penpot source file, that file is MPL and must be shared; if you write a plugin, it is yours. The architecture makes the low-risk path the easy one.

9. Deployment: Docker Compose

The lowest-friction self-host is the official Docker Compose file, which brings up the Penpot app, PostgreSQL, and Valkey together. A minimal mental model: ``yaml

penpot stack: app + postgres + valkey (redis-compatible)

services: penpot-postgres: image: postgres:16 environment: POSTGRES_DB: penpot POSTGRES_USER: penpot POSTGRES_PASSWORD: change-me volumes: [penpot_pg:/var/lib/postgresql/data] penpot-redis: image: valkey/valkey:8 volumes: [penpot_redis:/data] penpot-app: image: penpotapp/penpot:latest depends_on: [penpot-postgres, penpot-redis] environment: PENPOT_DB_HOST: penpot-postgres PENPOT_REDIS_HOST: penpot-redis PENPOT_HTTP_HOST: design.yourdomain.com ports: ["9001:9001"] ` For production, put it behind your reverse proxy with TLS, restrict the admin bootstrap, and back up PostgreSQL on a schedule. Migrations auto-apply on startup, so the main operational discipline is the DB backup, not manual schema work.

10. SSO and RBAC in Practice

Wire Penpot to your IdP via OIDC (or OAuth/LDAP) — all free in self-hosting. Map roles: Owners and Admins manage the instance and teams; Editors design; Viewers consume. For most orgs, OIDC plus the built-in RBAC covers the access model completely. Enforce MFA at the IdP (Keycloak or Authelia) so Penpot inherits it without implementing anything itself. The gap to name: if your compliance regime requires SAML/SCIM (common in larger enterprises with Okta/Azure AD federation), Penpot's self-hosted free tier does not provide it — that is Enterprise. Plan your identity integration around OIDC where possible, and treat SAML as a paid-plan conversation. This is the one place the "free and open" story has a boundary.

11. Where Your Data Goes

Precisely, when you self-host Penpot:

• Designs (SVG/CSS/JSON, components, prototypes) live in your PostgreSQL and are rendered from open formats. They do not leave your infrastructure.
• Presence and cache live in your Valkey instance.
• Authentication via OIDC/OAuth/LDAP is brokered by your IdP. Penpot does not phone home for login.
• Asset files (uploaded images, fonts) live in your configured storage (the Penpot volume or your object storage).
• Telemetry: the self-hosted core does not ship a mandatory phone-home beacon. There is no vendor harvesting your designs.

The sovereignty win is total here: every byte of your design IP is in infrastructure you control, in formats you can read without Penpot. That is the design-world equivalent of owning your docs — and it is why Penpot sits naturally in this blog's stack.

12. Penpot vs Figma: The Real Trade

The comparison everyone makes:

• Licensing: Figma is proprietary SaaS with per-seat cost; Penpot is MPL-2.0, self-hostable at $0 software cost.
• Format: Figma is proprietary binary; Penpot is SVG/CSS/JSON open standards.
• Data residency: Figma Cloud is vendor-controlled; Penpot self-hosted is 100% yours.
• SAML/SCIM: Figma Enterprise has it; Penpot self-hosted free does not (Enterprise plan does).
• Ecosystem: Figma's plugin and template ecosystem is larger; Penpot's is younger but growing with its plugin API and MCP.

The verdict from the field: strong buy for sovereignty-focused teams and large collaborative teams that want to eliminate the Figma per-seat floor. Caution for teams deep in the Adobe ecosystem or dependent on Figma-specific plugins — migrating requires workflow adjustment and designer retraining. For a self-hoster, the trade is operational: you run Postgres and Valkey, and you accept a smaller plugin market, in exchange for owning the assets.

13. Penpot vs Excalidraw

A common confusion: is Penpot just Excalidraw? No. Excalidraw (covered in this series) is a hand-drawn-style whiteboard for sketches and diagrams — great for architecture scribbles and brainstorming, not for product UI design. Penpot is a structured design and prototyping tool with components, design tokens, layouts, and a developer handoff pipeline. They are complementary: Excalidraw for the napkin sketch, Penpot for the shipped design. If your need is "draw a boxes-and-arrows diagram," Excalidraw is lighter and enough; if your need is "design the actual product screens with reusable components," Penpot is the tool.

14. The Maintenance Reality

Penpot is actively maintained — multiple releases per quarter through 2026, a large contributor base, and high project-health scores from independent trackers. The "maintenance: low" rating some tools assign refers to operational complexity (periodic image updates and PostgreSQL backups; migrations auto-apply), not development activity. Development is vigorous; operations are moderate. For an operator that is the good kind of "low" — the software is alive, and running it is not demanding once deployed. The one structural caveat is jurisdiction: Kaleidos is Spain/US, so a US-parent entity creates theoretical CLOUD Act exposure for the hosted Penpot Cloud. Self-hosting neutralizes that entirely, because the data never touches Kaleidos. This is exactly the sovereign operator's move: take the open-source software, keep the data, erase the jurisdiction risk.

15. Performance and Scaling

Penpot is moderately complex to run (rated ~3/5). A single Docker Compose node handles a small team comfortably. At scale — many concurrent collaborators, large files — you move to Kubernetes with the Helm charts, scale the app tier horizontally, and keep PostgreSQL and Valkey as the stateful cores. The JVM backend benefits from adequate heap; size the container memory for your concurrent-editing peak, not your average. Real-time collab is the latency-sensitive path. Keep the app tier close to the Valkey tier (same network, low RTT), and configure your reverse proxy for WebSocket with sane timeouts. Most "collaboration feels laggy" reports trace to proxy or Valkey network config, not the app itself.

16. Backup and Disaster Recovery

Because state lives in PostgreSQL (designs) and Valkey (presence/cache, reconstructable), backup is the familiar PostgreSQL dump plus your asset volume. Migrations auto-apply on startup, so a restore is: restore the DB, restore the assets, bring the stack up, let it migrate forward. Schedule the Postgres dump offsite; the Valkey cache need not be backed up (it rebuilds). As with every stateful app in this series, a dump to the same disk is not a backup — ship it offsite. The format portability is your second safety net: even if the DB is lost, your designs are SVG/CSS/JSON that Penpot can re-import, and that you can read without Penpot at all. That redundancy — DB backup plus format portability — is unusually strong.

17. Security Hardening

• Terminate TLS at your reverse proxy (Caddy/Traefik); do not expose the app port directly.
• Enforce MFA at your IdP; broker all login via OIDC.
• Restrict the bootstrap/admin routes to a trusted network where possible.
• Keep images updated (the project ships security fixes in point releases, e.g., the SVG-exporter CVE fix in 2.17.2).
• Sanitize any user-supplied content fed into plugins or the MCP server; treat the AI/agent surface as untrusted input.
• Back up PostgreSQL offsite on a schedule.

None of this is exotic; it is standard web-app hardening applied to a JVM stack. The main difference from a PHP/Node app is the JVM log vocabulary when you debug.

18. Who Should Run It — and Who Shouldn't

Run Penpot if: you want design assets you own in open formats; you want to eliminate Figma's per-seat cost at scale; your identity layer is OIDC/OAuth/LDAP; you can run Postgres and Valkey; and you value the design-to-code handoff. This is the strongest fit in the self-hosted design category for sovereignty-focused teams. Do not run Penpot if: you require SAML/SCIM from the tool itself (that is Enterprise); your designers are locked into Figma-specific plugins and unwilling to retrain; or you cannot run a stateful JVM + Postgres + Valkey stack. In those cases, the operational or licensing boundary will bite. For a lightweight sketch tool, Excalidraw is the lighter choice; for structured product design with ownership, Penpot is the answer.

19. The Verdict

Penpot is the rare design tool that is both open and sovereign. MPL-2.0 means you can run it, modify it, and build around it without virally infecting your own IP — a cleaner license story than the AGPL wikis in this series. The SVG/CSS/JSON storage means your designs are portable in a way Figma's binary format simply is not. The free self-hosted tier covers OIDC, RBAC, real-time collab, and the plugin/MCP surface; only SAML/SCIM and audit legs sit behind Enterprise. The costs are operational: a Clojure/JVM + Postgres + Valkey stack to run, and a smaller plugin ecosystem than Figma. For a team that treats design files as core IP and wants them out of a vendor's cloud, those costs are the price of ownership — and ownership is the point. Self-host it, broker auth at your IdP, back up PostgreSQL, and your product's visual definition is yours in every sense that matters.

20. Inside the Open Format: SVG, CSS, JSON

It is worth being concrete about what "open standards" means on disk. A Penpot shape is an SVG element — a rectangle is <rect>, a path is <path>`, with attributes for geometry and style. A color or spacing scale is expressed as CSS custom properties. The document structure, component definitions, and prototypes are JSON. None of these require Penpot to interpret; a browser renders the SVG, a CSS processor applies the variables, and any JSON tool can walk the document tree. This is why the portability claim is not marketing. If you export a Penpot file, you get artifacts your existing tooling already understands. You can diff them in Git, lint them in CI, and generate code from them with your own scripts. Contrast that with a proprietary binary: extracting value requires the vendor's software and the vendor's permission. Penpot's format is the escape hatch baked into the data model.

21. Design Tokens and Theming

Penpot supports design tokens — named values for colors, typography, spacing, and shadows — that map to CSS custom properties. This lets a team define a design system once and apply it across files, and it lets engineering consume the same tokens as real CSS variables rather than hardcoded values. The 2.17 line expanded token management and added layer blur and token detachment handling, signaling that tokens are a first-class part of the roadmap. For a sovereignty-focused team, tokens are the bridge between design and code: the source of truth lives in Penpot, exports as CSS, and your frontend imports the same values. That closes the "design says one thing, code does another" gap without a proprietary token platform in the middle.

22. Components and Libraries

Penpot has a component model: reusable elements with variants and overrides, organized into libraries that teams can share. This is the structured-design backbone that separates it from a whiteboard. Components keep a design consistent across dozens of screens, and library sharing lets a design system propagate to every file that consumes it. Operationally, components and libraries are where Penpot earns its place in a product team. A whiteboard (Excalidraw) cannot do this; a docs wiki (BookStack/Wiki.js) should not try. Penpot sits in the layer between "sketch" and "spec" — the actual product surface — and components are what make that layer scalable.

23. Prototyping and User Flows

Beyond static design, Penpot supports prototyping: wiring screens together with interactions (click, hover, time) to simulate user flows. The prototype viewer moved to a WASM Skia engine in 2.17.0, improving rendering fidelity. For a team that needs to validate a flow before building it, this is the difference between "here is a screen" and "here is the journey." The practical note: prototypes are part of the same open document, so they travel with the design and can be shared or exported. They are not a separate proprietary artifact. That keeps the whole product definition — visuals, components, and flows — inside the portable format.

24. MCP Integration: Design as a Queryable Source

The 2.15.0 release (May 2026) added an MCP server, and 2.16.1 expanded it with WebSocket proxy configuration and tenant isolation. MCP lets external agents and AI tooling read the design graph programmatically. Concretely, that means a code-generation agent can ask Penpot "what are the components in this file and their tokens" and get structured answers, instead of screenshotting and guessing. This is the design-to-code workflow upgraded to the agent era. For a self-hoster, the guidance is to treat the MCP surface as untrusted input: sanitize what flows in, scope what flows out, and keep the agent's access to read-only where possible. The integration is powerful; the security model around it is yours to enforce.

25. Penpot in the Open-Source Design Field

Penpot is not the only open design tool, but it occupies a specific niche:

• Excalidraw (covered here): hand-drawn whiteboard, sketches only. Lighter, not a product-design tool.
• tldraw: open-source SDK for building canvas apps; powerful but a toolkit, not a turnkey Figma alternative.
• Gravit / others: various, with mixed licensing and maintenance.
• Penpot: the turnkey, structured, SVG-based product-design and prototyping platform with real-time collab and SSO.

The differentiator is the combination: open format plus structured design plus collaboration plus self-hostable SSO. Most alternatives miss one of those. That is why Penpot is the default answer to "open-source Figma" in 2026.

26. Total Cost of Ownership vs Figma

The software cost is $0 (MPL-2.0). The real TCO is infrastructure and ops:

• Penpot self-hosted: server (Postgres + Valkey + app), roughly equivalent to a small VPS or a couple of containers; your time for updates and backups; no per-seat fee regardless of team size.
• Figma: $12–$75/user/month depending on tier; vendor lock-in via proprietary format; data residency in Figma Cloud.

For a 20-person team, Figma's annual seat cost alone often exceeds the entire infrastructure bill of a self-hosted Penpot by an order of magnitude. The trade is that you own the operations. For large collaborative teams, Penpot's $0 software cost plus owned data is a strong financial and sovereignty argument; for a two-person team, Figma's convenience may still win on pure effort.

27. Common Failure Modes

Collaboration lag or disconnects. Usually proxy WebSocket misconfig or Valkey network latency. Fix the proxy (WebSocket upgrade, timeouts) and colocate Valkey with the app tier. SVG exporter error / security warning. Keep images updated; 2.17.2 fixed an SVG-exporter CVE. Running old images is the risk. Login loop on OIDC. Redirect-URI mismatch or missing claim mapping in your IdP client. Replicate the exact callback URL Penpot shows. Migrations fail on startup. Almost always a restored DB from a mismatched version. Restore from a backup taken on the same Penpot version, or let the documented migration path run from a known-good state. Asset 404s after move. Uploaded assets live in the Penpot volume or object storage; a DB-only restore loses them. Back up both.

28. Migrating from Figma

Moving from Figma is a workflow project, not a checkbox. Steps that work: 1. Audit the library. Figma components, styles, and plugins rarely map 1:1. Decide what to rebuild as Penpot components and tokens versus what to drop. 2. Export what exports. Figma can export SVGs and some structure; Penpot imports SVG. Expect to rebuild components and tokens natively rather than import them perfectly. 3. Rebuild the design system in Penpot as tokens + components + libraries. This is the durable win — a portable system, not a translated one. 4. Pilot one product area before migrating the whole org. Train designers on the open-format model and the handoff pipeline. 5. Wire SSO and MFA at your IdP before onboarding the team. Budget designer retraining time. Teams reliant on advanced auto-layout or proprietary Figma plugins should pilot before committing. The payoff is owned assets and no per-seat floor; the cost is a real migration.

29. The Sovereignty Scorecard

• Data ownership: 10/10. Designs in your Postgres, in open SVG/CSS/JSON; no vendor custody.
• License freedom: 9/10. MPL file-level copyleft; run, modify, build around — without infecting your IP.
• Operational cost: 7/10. JVM + Postgres + Valkey is moderate but standard; updates are light.
• Lock-in risk: 1/10. Open formats mean you can leave with your assets intact, no converter needed.
• Maintenance risk: 8/10. Actively developed, multiple releases per quarter, healthy project.

Net: a strong yes for teams that want design sovereignty. The only real boundaries are SAML/SCIM (Enterprise) and the operational stack — both manageable for a competent self-hoster.

30. FAQ

"Is Penpot really free?" The software is MPL-2.0 and free to self-host. SAML/SCIM and audit legs are Enterprise features; OIDC/OAuth/LDAP and RBAC are free. "Does MPL force me to open my designs?" No. MPL covers Penpot's source files; your design files (SVG/CSS/JSON) are not derivative of that source and stay yours. "Can I run a modified Penpot as a service?" Yes. You must open the MPL-covered files you changed; your surrounding proprietary systems are unaffected. No AGPL network clause. "Is it production-ready?" Yes — 2.17.x is stable and actively shipped. Use the stable tag, not a dev build. "Do I need Kubernetes?" No. Docker Compose suffices for a team; Helm is for scale.

31. Penpot for Non-Designers

A note for the developers and operators who will never draw a screen but will live next to Penpot: the open format is your leverage. Because designs are SVG/CSS/JSON with tokens as CSS variables, you can treat the design system as a dependency your frontend consumes, not a PDF someone emails you. Read component definitions directly, pull token values into your build, and use the MCP server to query the design graph in CI — for example, fail a build if a used color is not in the token set. This is why self-hosting Penpot matters even if you personally never open the editor: the designs become infrastructure-accessible. A closed tool keeps that graph behind a login and a proprietary format; Penpot puts it in your network, in open artifacts, queryable by your own systems. For a team that wants design and code to share one source of truth, that accessibility is the whole point.

32. Reading the 2026 Roadmap Signal

The release cadence through 2026 tells you where the project is heading. The 2.15–2.17 line added MCP integration, WebGL rendering (beta), layer blur, token management, a find-and-replace tool, and a security fix to the SVG exporter — a steady mix of capability and hardening. The MCP and plugin-API expansion signals a deliberate push to make Penpot an open hub for agentic and automated design workflows, not just a human editor. For an adopter, the signal is healthy: the project is investing in both the core craft (rendering, tokens) and the integration surface (MCP, plugins) that makes it useful in a modern stack. The caveat is the same as always with fast-moving releases — pin your image tag, read the changelog for breaking changes, and stage upgrades, because point releases do fix security issues you want promptly but can also shift behavior.

33. A Practical Deployment Checklist

Before you call Penpot "done":

• [ ] PostgreSQL and Valkey running as persistent volumes, not ephemeral.
• [ ] App behind Caddy or Traefik with TLS and WebSocket support for collaboration.
• [ ] OIDC wired to your IdP (Keycloak/Authelia); MFA enforced at the IdP.
• [ ] Admin bootstrap route restricted to a trusted network.
• [ ] PostgreSQL dumped offsite on a schedule; assets volume backed up too.
• [ ] Image tag pinned; upgrade staged after reading the changelog.
• [ ] MCP server, if used, scoped read-only and treated as untrusted input.
• [ ] Design tokens defined as the shared source of truth with engineering.
• [ ] A pilot product area migrated before org-wide rollout.

Tick those and you have a sovereign design platform: owned data, open formats, free software, and a manageable operational surface. That is the Penpot deal in 2026.

34. Why This Belongs in a Sovereign Stack

The through-line of this blog is simple: own the layers that matter, and know exactly where each byte lands. Penpot closes a layer most self-hosters forget — the design layer. Your docs live in BookStack or Wiki.js, your identity in Keycloak or Authelia, your edge in Caddy, and your designs in Penpot: every strategic asset is now in infrastructure you control, in formats you can read without the vendor. Penpot's MPL license and SVG/CSS/JSON storage mean that layer is both free and portable, which is the precise combination this series exists to find. Adopt it, broker its auth, back up its database, and your product's visual definition is yours in the only sense that survives a vendor changing its mind. For a few containers and an afternoon, that is the cheapest sovereignty you will buy all year. Run it, own it, and keep the formats open — that is the whole Penpot proposition in one line.

Related

For the rest of a sovereign, self-hosted stack, these pieces from our series travel with Penpot:

• BookStack: The MIT Wiki That Refuses to Be a Platform — your docs layer, in a permissive license that pairs cleanly with Penpot's MPL.
• Wiki.js: Git-Backed Docs With an AGPL License — the contrast in copyleft philosophy (AGPL network clause vs MPL file-level).
• Excalidraw: The Open Whiteboard — the lighter sketch tool to pair with Penpot's structured design.
• Keycloak: The Apache-2.0 Identity Platform — the IdP to broker Penpot's OIDC login.
• Caddy: The Web Server That Does TLS for You — the reverse proxy in front of Penpot's collaboration port.