pad.ws

Open-source canvas IDE, honestly reviewed. No marketing fluff, just what you actually get when you try to run it yourself.

TL;DR

• What it is: An MIT-licensed browser app that merges an Excalidraw whiteboard with a full cloud development environment — you can sketch architecture diagrams and run terminal sessions on the same canvas [1][README].
• Who it’s for: Developers who split their time between visual design tools (Miro, Excalidraw) and code editors, and want those two surfaces unified. This is not a tool for non-technical founders.
• Cost savings: GitHub Codespaces charges ~$0.18/core-hour after a 60-hour free monthly allowance. Gitpod charges $9/month for 100 hours. pad.ws self-hosted is free software on a VPS — but the real cost is the complexity of the setup, which includes five separate services [README].
• Key strength: The concept is genuinely novel — Excalidraw is one of the best whiteboard tools in the open-source world, and Coder is a proven cloud dev environment platform. Gluing them together on a single canvas is a sharp idea [README][1].
• Key weakness: The project explicitly warns it is in “early development stage” and “not safe for real-life use without further configurations.” Self-hosting requires five separate services, a full Keycloak OIDC configuration, and has only been tested on Ubuntu [README]. Six contributors, 90 commits total — this is early-stage software.

---

What is pad.ws

pad.ws is a browser-based application that puts a freeform whiteboard and a full IDE on the same canvas. You can draw boxes, write notes, sketch system diagrams with Excalidraw — and then open a real terminal or VS Code directly within that same whiteboard view. The pitch is that you stop bouncing between a design tool tab and a code editor tab [README][1].

The engineering foundation is two well-established open-source projects stitched together: Excalidraw for the whiteboard layer and Coder for the cloud development environment provisioning. Excalidraw needs no introduction — it has millions of users, a clean hand-drawn aesthetic, and an excellent collaborative mode. Coder is a workspace platform that provisions containerized dev environments on your own infrastructure, with support for VS Code, JetBrains, and SSH connections [README].

What pad.ws adds is the integration layer: a backend that coordinates authentication (via Keycloak), session management (via Redis), persistence (via PostgreSQL), and the canvas state that binds your Excalidraw drawings to active Coder workspaces. When you’re looking at a system diagram on your canvas and you want to run something, you open a terminal pane inside the drawing. Your desktop VS Code or Cursor can also SSH into the same workspace if you prefer working locally [README].

The project is built by coderamp-labs, is written in TypeScript and Python [1], and sits at 4,055 GitHub stars with 226 forks as of this review. There is a managed cloud instance at pad.ws that is currently free during beta, offering Ubuntu dev environments with no setup required [README].

---

Why people choose it

The honest answer: not many external reviews exist yet. pad.ws is young enough that coverage is thin — LinuxLinks catalogued it as a notable open-source whiteboard tool [1], but detailed user reviews haven’t accumulated at the scale of more established tools.

What the GitHub trajectory tells you: 4,055 stars with only 90 commits and 6 contributors is a signal that the concept resonated immediately, even if the implementation is still maturing. The star-to-commit ratio suggests a lot of people bookmarked it to try later rather than running it in production today.

The appeal is clear from the concept alone. Developers who do architectural work know the friction: you sketch in Miro or Excalidraw, then switch to a terminal to test your idea, then back to the diagram to update it, then back to the editor. pad.ws bets that collapsing those into one canvas surface reduces enough context-switching friction to be worth the setup cost.

The managed cloud option (free during beta) is the path most people are probably taking rather than self-hosting, and that’s the right call for now.

---

Features

Based on the README and the official website:

Whiteboard layer (via Excalidraw):

• Full Excalidraw canvas: freehand drawing, shapes, text, arrows, hand-drawn aesthetic [README]
• Sketch architecture diagrams, wireframes, flow charts alongside your code [README]
• Visual ideation and technical work in the same browser tab [1]

IDE layer (via Coder):

• Full terminal access inside the whiteboard canvas [README]
• VS Code in browser, directly within the whiteboard [README]
• Connect your local VS Code or Cursor desktop client via SSH to the same workspace [README]
• Ubuntu dev environments on the managed cloud instance [README]

Infrastructure and integrations:

• Docker and Docker Compose for self-hosted deployment [README]
• PostgreSQL for canvas and configuration persistence [README]
• Redis for session management and caching [README]
• Keycloak as OIDC provider for authentication — handles user management for both the pad app and Coder [README]
• REST API available through the underlying Coder layer [merged profile]
• Access from any device via browser — no local install required [README][1]

What is not here (yet):

• No Windows or macOS host support for self-hosting (Ubuntu only tested) [README]
• No simplified deployment path — no Helm charts mentioned, no one-click cloud deploy
• No team collaboration features mentioned in the README — this appears to be single-user or small-team at current stage
• No documented plugin or extension system beyond what Coder and Excalidraw already provide

---

Pricing: SaaS vs self-hosted math

pad.ws managed cloud:

• Currently free during beta — Ubuntu dev environments, no setup [README]
• No public pricing page yet; post-beta pricing is not disclosed

Self-hosted (Community Edition):

• Software license: $0 (MIT) [README]
• VPS cost: $6–20/month depending on provider (you need enough RAM for Docker + PostgreSQL + Redis + Keycloak + Coder + the pad app running simultaneously)
• Your time: significant — see Deployment section below

Comparable paid alternatives:

• GitHub Codespaces: 60 free core-hours/month for personal accounts, then $0.18/core-hour (2-core machine = ~$0.36/hr). A developer using it 20 hours/week blows past the free tier in 3 weeks and starts paying ~$35–50/month.
• Gitpod: Free tier 50 hours/month, Standard plan $9/month for 100 hours, paid tiers up to $35/month
• Replit: Free tier with limits, Core plan $20/month

The self-hosted math works in pad.ws’s favor — if you can run it, you get unlimited dev environment hours. The catch is that the managed cloud pricing is unknown post-beta, and the self-hosted path has a serious complexity tax that makes it impractical for non-technical users.

---

Deployment reality check

The README is unusually candid: “IMPORTANT NOTICE: This repository is in early development stage. The setup provided in docker-compose.yml is for development and testing purposes only. This simplified example lets you host pad on localhost but is not safe for real-life use without further configurations.” [README]

That warning is accurate. Here is what self-hosting actually requires:

Services you need to run:

1. PostgreSQL — canvas and configuration persistence
2. Redis — session management, password-auth configured
3. Keycloak — the OIDC identity provider (this is the hard part)
4. Coder — the dev environment provisioning layer
5. The pad app itself — the frontend/backend that ties it all together

Keycloak setup alone involves:

• Creating a realm
• Creating a client with Client Authentication enabled
• Copying client secrets into your .env
• Creating users with Email verified ticked
• Creating an Audience mapper in Client Scopes with Add to access token enabled

This is not the kind of configuration you complete in 30 minutes on a first attempt. Anyone who has run Keycloak before will manage it; anyone who hasn’t will spend several hours on documentation.

Beyond Keycloak, Coder also requires manual configuration:

• Finding your Docker group ID and injecting it into .env
• Logging into the Coder UI, creating an administrator, creating a workspace template
• Generating an API key and retrieving the template ID and organization ID from API endpoints

What can go wrong:

• The docker-compose.yml is for development and localhost use — HTTPS, domain configuration, and production hardening are left entirely to you [README]
• Ubuntu-only testing means other Linux distributions are unsupported territory
• Six contributors total means issues may sit unanswered for longer than established projects

Realistic time estimate:

• Experienced DevOps engineer who knows Keycloak: 2–3 hours
• Developer comfortable with Docker but no Keycloak experience: 4–8 hours
• Non-technical founder: this is not the target audience — managed cloud is the right path

---

Pros and Cons

Pros

• Concept is genuinely sharp. Unifying a whiteboard and a dev environment on a single canvas addresses real developer friction — most tools force you to context-switch between design and code [README][1].
• MIT licensed. You can self-host, fork, and embed without a commercial agreement [README].
• Built on proven foundations. Excalidraw and Coder are both well-maintained, widely used projects. pad.ws is inheriting years of development rather than rebuilding from scratch [README][1].
• Browser-accessible from any device. Your dev environment follows you — no local setup on each machine [README][1].
• Free during beta on managed cloud. The path of least resistance is the managed instance, which currently costs nothing [README].
• Desktop client support. VS Code and Cursor can connect to the workspace via SSH — you’re not locked into in-browser editing if you prefer your local editor setup [README].
• 4,055 stars shows real demand. The concept is resonating even before the project is production-ready.

Cons

• Explicitly early-stage and not production-ready. The README says so directly. This is the most important thing to know [README].
• Self-hosting requires five services and Keycloak expertise. The setup is significantly more complex than tools like Activepieces, Gitea, or most other self-hosted tools in this category. Keycloak alone is a serious time investment for anyone unfamiliar with it [README].
• Ubuntu-only. Tested on Ubuntu only. Other Linux distributions are not supported [README].
• Tiny team. Six contributors, 90 commits total as of this review. Longevity and maintenance pace are unknowns [README].
• No production-grade deployment documentation. The provided docker-compose.yml is for local development. HTTPS, domain setup, backups, and security hardening are entirely undocumented [README].
• Post-beta pricing unknown. The managed cloud is free now, but pricing has not been announced. If you build a workflow on the managed instance, you’re betting on pricing that doesn’t exist yet [README].
• Limited third-party coverage. Only one independent review [1] found, and it’s a brief listing rather than a hands-on evaluation. No community forums or r/selfhosted threads to draw on for real-world failure reports.
• No Windows/macOS host support for self-hosting [README].

---

Who should use this / who shouldn’t

Use pad.ws if:

• You are a developer who splits time between diagramming tools and terminals and wants them in one place.
• You want to try the managed cloud instance during the free beta period before committing to anything.
• You have experience with Keycloak or are willing to invest the setup time.
• You’re running a technical team that does whiteboard sessions before diving into code — and wants those sessions to be closer to the actual development environment.
• You accept “early-stage software” at face value and can tolerate rough edges.

Skip it for now if:

• You need production-ready self-hosted infrastructure today. The README is explicit that this is not that [README].
• You’re a non-technical founder. The deployment complexity requires someone with DevOps experience.
• You’re on Windows or macOS and want to self-host [README].
• You need team governance features, SSO, or audit logs — there is no documentation suggesting these exist yet.

Wait and revisit if:

• You’re interested in the concept but the early-stage warning puts you off. Watch the GitHub — if commits, contributors, and production deployment documentation grow substantially in the next 6–12 months, this becomes more compelling.

---

Alternatives worth considering

• Coder (standalone) — pad.ws is built on top of Coder. If you want cloud dev environments without the whiteboard, Coder alone is more mature, better documented, and production-ready. MIT licensed, 8,000+ GitHub stars.
• Gitpod — the commercial leader in browser-based dev environments. More polished, closed-source-ish, $9–35/month plans. Not self-hostable in the same way.
• GitHub Codespaces — Microsoft’s equivalent. Deep VS Code integration, pay-per-use, no self-hosting option.
• Excalidraw (standalone) — if you just want the whiteboard part, self-hosted Excalidraw is a single Docker container and takes 5 minutes to deploy.
• CodeSandbox — browser-based IDE for web development, not general-purpose dev environments.
• DevPod — self-hosted dev environments with no server required, client-side tool, much simpler to set up than pad.ws.
• Replit — managed browser IDE, not self-hostable, but polished and beginner-friendly.

For the non-technical founder audience this site typically addresses: none of these make sense to self-host except possibly standalone Excalidraw for the whiteboard use case alone. The dev environment layer is inherently a developer tool.

---

Bottom line

pad.ws is one of the more interesting ideas in the self-hosted developer tools space in recent memory — putting Excalidraw and a full Coder dev environment on the same canvas is a legitimate workflow improvement for developers who bounce between design and code. The MIT license and managed cloud free beta make it easy to explore. The problem is that self-hosting it today requires running five separate services, configuring Keycloak from scratch, and tolerating a codebase that its own authors describe as “not safe for real-life use without further configurations.” If you’re a developer comfortable with that — go try the free managed cloud instance now, and check back on the self-hosted path in 6–12 months once the project matures. If you’re evaluating it for a non-technical team or for production infrastructure today, it’s too early.

---

Sources

1. pad.ws — whiteboard as an IDE (LinuxLinks) — https://www.linuxlinks.com/pad-ws-whiteboard-ide/

Primary sources:

• GitHub repository and README (coderamp-labs/pad.ws) — https://github.com/coderamp-labs/pad.ws (4,055 stars, 226 forks, MIT license, 6 contributors)
• Official managed instance — https://pad.ws
• Excalidraw (whiteboard layer) — https://github.com/excalidraw/excalidraw
• Coder (dev environment layer) — https://github.com/coder/coder