WBO

WBO is a real‑time collaborative whiteboard built as a self‑hosted Node.js application. It exposes a single HTTP endpoint that serves both the static front‑end and a WebSocket API for drawing operations. The server keeps an in‑memory representation of each board, which is persisted to the local file system as JSON snapshots. This design allows instant replication of strokes across all clients while keeping storage requirements minimal, making it suitable for small to medium‑sized deployments.

Technical Stack

• Runtime: Node.js ≥ 10 (ES6 modules, async/await)
• Frameworks: Express for HTTP routing; ws or native WebSocket support for real‑time messaging
• Data Persistence: Plain JSON files under /opt/app/server-data; no external database required
• Front‑end: Vanilla JavaScript with Canvas API; minimal dependencies (no heavy frameworks)
• Containerization: Official Docker image (lovasoa/wbo) exposes port 80, mounts a host directory for board persistence
• Reverse Proxy: Supports deployment behind Nginx/Traefik via standard WebSocket proxying; can be served from a sub‑path with proper rewrite rules

Core Capabilities & APIs

• Real‑time collaboration: Broadcasts drawing events (stroke start, move, end) to all connected clients with low latency
• Undo/Redo: Maintains a per‑board operation stack; exposes undo and redo actions via WebSocket messages
• Board Lifecycle: Clients can create, load, and delete boards through simple REST endpoints (/boards/:id) or via WebSocket commands
• Persistence API: GET /api/boards/:id returns the current board state; POST /api/boards/:id accepts a JSON payload to overwrite the state
• Webhooks: Custom events can be emitted on board changes; developers can hook external services via HTTP callbacks (see Wiki for configuration)

Deployment & Infrastructure

Running WBO is intentionally lightweight. The Docker image runs on a single process, consuming < 50 MB of RAM under typical load. It can be deployed on any Linux host with Docker, or directly on a Node.js‑enabled server. For scalability, each board is isolated in memory; horizontal scaling can be achieved by running multiple instances behind a load balancer and persisting boards to shared storage (e.g., NFS, S3‑compatible object store) or by introducing a lightweight database layer (SQLite, Redis). The application supports binding to specific interfaces and ports via environment variables (PORT, HOST), facilitating integration with reverse proxies or container orchestrators.

Integration & Extensibility

WBO’s open source codebase allows developers to extend functionality without modifying the core. The plugin architecture is minimal: any JavaScript module that exports an init(app) function can hook into the Express app or WebSocket server. This enables adding authentication layers, custom drawing tools, or analytics dashboards. The JSON board format is human‑readable and versioned, allowing third‑party tools to import/export boards. Additionally, the WebSocket protocol is documented in the Wiki, making it straightforward to write external clients (e.g., mobile apps or desktop widgets) that can render and interact with boards in real time.

Developer Experience

The project emphasizes clarity: concise README, inline comments, and a small dependency tree. Configuration is handled through simple environment variables or command‑line flags, with sensible defaults that work out of the box. The community is active on GitHub issues and discussions, where feature requests and bug reports are addressed promptly. The documentation covers container deployment, reverse‑proxy setup, and API usage in depth, making it easy for developers to integrate WBO into existing stacks or to contribute new features.

Use Cases

• Remote Education: Teachers can host private boards for live math or design lessons, sharing them via a sub‑folder on their school’s domain.
• Collaborative Design: Product teams can prototype UI sketches in real time, with persistent boards stored on a shared NAS.
• Interactive Workshops: Facilitators can create anonymous boards for brainstorming sessions, ensuring all participants see updates instantly.
• Embedded Whiteboards: Developers can embed WBO behind a reverse proxy into larger web applications (e.g., learning management systems) without exposing the entire codebase.

Advantages

WBO offers a lightweight, self‑hosted alternative to commercial whiteboard SaaS solutions. Its pure Node.js implementation eliminates the need for heavyweight databases or external services, reducing operational overhead. The open license (MIT) allows unrestricted modification and redistribution, which is attractive for enterprises with strict compliance requirements. Performance-wise, the in‑memory board model delivers sub‑100 ms latency on modest hardware, while the minimal front‑end keeps browser resource usage low. Overall, developers choose WBO for its simplicity, transparency, and the freedom to host and extend a real‑time collaboration tool entirely within their own infrastructure.