pad.ws

pad.ws merges the freeform expressiveness of an interactive whiteboard with a fully functional development environment, all running in the browser. Built on a fork of Excalidraw, it lets developers sketch architectures, write diagrams, and embed live terminals or VS Code sessions directly into their canvas as interactive elements — no switching between apps.

Under the hood, pad.ws uses a Python FastAPI backend backed by PostgreSQL for canvas persistence and Redis as both a session store and a real-time message bus. Real-time collaboration is handled via WebSocket connections feeding into Redis streams and pub/sub channels, with a background CanvasWorker that asynchronously processes canvas state and periodically flushes it to the database. Each pad tracks per-user viewport state, enabling multiple collaborators to have independent views of the shared canvas.

Cloud development environments are powered by Coder, which provisions containerized workspaces on demand. The pad application communicates with the Coder API to start, stop, and introspect workspaces, then embeds the resulting terminal or VS Code connections directly into Excalidraw embeddable elements. Identity is managed through Keycloak via OpenID Connect, giving each user a secure, authenticated workspace tied to their identity.

pad.ws is self-hostable via Docker Compose and is actively evolving toward a shared cloud development model where teams can collaborate in real time — drawing, coding, and executing in the same unified space.

What You Get

• Whiteboard-Embedded IDE - Excalidraw canvas with custom embeddable elements that render live terminals, VS Code sessions, Monaco code editors, and workspace state indicators directly inside your drawing.
• Real-Time Collaboration - Multi-user WebSocket sessions backed by Redis streams and pub/sub channels, with cursor presence, user join/leave events, and per-user viewport state stored independently per pad.
• Coder-Powered Workspaces - On-demand cloud dev environments provisioned via the Coder API, supporting containerized Ubuntu workspaces accessible from both the browser and desktop clients like VS Code and Cursor.
• Multi-Pad Tab Management - Create, rename, delete, and switch between multiple pads in a tab bar, with sharing controls (private, whitelist, public) per pad.
• Persistent Canvas with Redis Cache - Canvas state is cached in Redis hashes per pad and periodically flushed to PostgreSQL by a background CanvasWorker, ensuring fast reads and durable storage.
• OIDC Authentication via Keycloak - Secure identity management with OpenID Connect through Keycloak, including session refresh, token validation, and audience-scoped access tokens that gate workspace provisioning.

Common Use Cases

• Architecture diagramming with live validation - A developer sketches a microservices diagram and embeds a terminal next to each service node to run commands and verify the architecture as they draw it.
• Collaborative pair programming sessions - Two developers open the same pad, see each other’s cursors in real time, and share a Coder workspace to code together without a separate screen share or meeting tool.
• Interactive technical presentations - An instructor prepares a pad with diagrams and embedded code editors, then walks through concepts live with students who can see cursor movements and run code in the same view.
• Rapid prototyping with instant execution - A developer sketches a data flow, embeds a terminal to scaffold the project, and iterates on code in an embedded editor—all within the same whiteboard canvas.
• Remote onboarding environments - A team lead shares a public pad with architecture diagrams and embedded workspaces pre-configured with the project stack, giving new team members a guided, runnable onboarding experience.
• System debugging with visual context - An engineer diagrams the problem area, embeds a terminal to inspect logs, and annotates findings directly on the canvas without losing the visual thread of the investigation.

Under The Hood

Architecture pad.ws follows a clean layered architecture that separates frontend rendering, API routing, domain logic, and persistence. The FastAPI backend organizes routes into distinct routers (auth, users, pads, workspaces, WebSocket) and delegates business logic to domain classes like Pad and User, which abstract over both Redis-cached state and SQLAlchemy-persisted records. The Pad domain entity implements a cache-aside pattern: reads prefer Redis hashes, falling back to PostgreSQL when the cache is cold, and a background CanvasWorker runs as a singleton task that consumes Redis streams and periodically flushes canvas state to the database. Real-time collaboration uses WebSocket connections per user per pad, with Redis streams handling durable collaborative events and Redis pub/sub handling high-frequency pointer updates through separate channels, keeping the two concerns cleanly decoupled.

Tech Stack The frontend is built with React 19 and TypeScript, bundled by Vite, using a maintained fork of Excalidraw as the canvas layer and TanStack Query for server state management. The backend runs Python 3.11 with FastAPI and Uvicorn, SQLAlchemy with asyncpg for async PostgreSQL access, and the redis-py async client for both stream and pub/sub workloads. Identity is handled by Keycloak 25 via OIDC using PyJWT and a JWKS client for token verification. Coder is integrated via its REST API for workspace lifecycle management. The entire stack is orchestrated with Docker Compose in host-network mode, with Keycloak, PostgreSQL, Redis, Coder, and the pad application running as separate containers.

Code Quality The codebase has no automated test suite — neither unit nor integration tests are present. Error handling leans on broad except blocks with print statements throughout the backend, which obscures failure modes in production. The frontend uses TypeScript with occasional escape hatches via any types, particularly in the Collab component’s class-based implementation. The backend has well-typed Pydantic models for API boundaries and SQLAlchemy models for persistence, but internal domain methods mix async and sync patterns inconsistently. CI is limited to a Docker build workflow, providing no quality gates for code correctness. Despite these gaps, the domain model design is coherent and the Redis integration is thoughtfully structured with separate stream keys and expiry management.

What Makes It Unique The core innovation is treating Excalidraw embeddable elements as a rendering surface for live development tooling rather than just linked web pages. pad.ws ships a custom embeddable renderer that inspects link prefixes on canvas elements and swaps in terminal iframes, Monaco editor instances, Coder workspace state indicators, and configurable action buttons — making whiteboard annotations into executable components. The per-user appState model stores each collaborator’s viewport and tool state independently within a shared pad document, enabling true multi-user sessions without overwriting each other’s canvas view. This combination of visual collaboration, identity-bound workspace provisioning, and in-canvas code execution has no direct analog in existing developer tooling.

Self-Hosting

pad.ws is released under the MIT License, which grants full permission to use, modify, distribute, and commercially deploy the software without restriction. There are no copyleft obligations, no open core limitations, and no license keys required. Self-hosters are free to integrate pad.ws into proprietary workflows, white-label it, or modify the source without any obligation to share changes.

Running pad.ws yourself requires operating at least five interdependent services: the pad FastAPI application, PostgreSQL, Redis, Keycloak, and Coder. The Docker Compose setup provided in the repository is explicitly documented as a development and localhost-only configuration, and the README warns that production deployments require further hardening — including reverse proxy configuration, HTTPS termination, network isolation, and careful Keycloak realm setup. Uptime, database backups, Redis persistence configuration, Coder workspace infrastructure costs, and Keycloak administration are entirely the operator’s responsibility. The operational surface area is substantial for a small team.

The project currently offers no paid or managed cloud tier with formal support SLAs, though an official hosted instance at pad.ws exists as a free beta. Compared to self-hosting, the managed offering removes all infrastructure burden and provides workspace availability without configuring Coder templates or Docker group permissions. Community support is available via Discord, and the project is actively evolving — the roadmap points toward shared cloud development environments and AI agent integration as next milestones. Self-hosters should expect meaningful setup effort and ongoing maintenance, particularly around Keycloak identity management and Coder workspace template configuration.