Colanode

Colanode is an open-source collaboration platform built for teams who want the capabilities of Slack and Notion without surrendering ownership of their data. It takes a local-first approach: every edit is written to a local SQLite database before being synced to the server, which means the app stays fully functional when connectivity drops and restores state instantly when it returns.

At its core, Colanode uses Conflict-free Replicated Data Types (CRDTs) powered by Yjs to handle concurrent edits from multiple users without manual conflict resolution. Whether two teammates are editing the same wiki page or a database record simultaneously, the system merges changes gracefully. Real-time messaging channels and direct messages use Redis-backed WebSockets for low-latency delivery.

The platform ships three clients — an Electron desktop app, a Progressive Web App, and a React Native mobile app via Expo — all sharing the same business logic through a platform-agnostic @colanode/client package. The server is a Fastify API backed by PostgreSQL (with the pgvector extension for future AI features) and Redis. Self-hosting is covered with Docker Compose configurations and Kubernetes Helm charts.

For teams not ready to run their own infrastructure, Colanode operates a free cloud beta with EU and US regions, making it easy to evaluate the product before committing to self-hosting.

What You Get

• Real-Time Chat - Channels and direct messages backed by Redis-powered WebSockets, delivering low-latency messaging synced via CRDTs across all connected devices.
• Rich Text Pages - A Tiptap/ProseMirror-based editor with block formatting, inline mentions, and embeds, with concurrent editing handled by Yjs so two users can write simultaneously without conflicts.
• Customizable Databases - Structured records with configurable field types, multiple views (table, kanban, calendar), and relational links, all stored locally in SQLite and synced incrementally.
• File Management - Upload, share, and organize files within workspaces, with pluggable storage backends: local filesystem by default, plus S3-compatible, Google Cloud Storage, and Azure Blob Storage.
• Offline-First Sync - Every client maintains a full local SQLite database; a background synchronizer handles CRDT state exchange with the server using typed mutation and query handlers, so work never blocks on connectivity.
• Cross-Platform Clients - Desktop (Electron), browser (Progressive Web App with SQLite via OPFS and Comlink web workers), and mobile (React Native via Expo) all share identical business logic through a shared client package.
• Self-Hosting Flexibility - Docker Compose for single-node deployments and Kubernetes Helm charts for production clusters, requiring only PostgreSQL with pgvector, Redis, and a storage backend.

Common Use Cases

• Privacy-first team collaboration - A distributed startup replaces Slack and Notion with a self-hosted Colanode instance, keeping all conversations, documentation, and project databases entirely within their own infrastructure and jurisdiction.
• Offline field work - A research team working in low-connectivity environments uses Colanode on laptops to write notes and update database records locally, with all changes syncing automatically once back online — no data lost, no manual merging.
• Compliance-driven knowledge base - A healthcare organization deploys Colanode on-premises to build an internal wiki and patient-project database, satisfying data residency requirements that prohibit third-party SaaS tools.
• Developer team documentation hub - An engineering team deploys Colanode via Kubernetes to centralize architecture docs, runbooks, and post-mortems alongside project chat, replacing a fragmented mix of Confluence, Slack, and Google Drive.
• Multi-workspace agency setup - A consulting firm connects a single Colanode desktop app to separate server instances for each client, isolating data per engagement while using one familiar interface.

Under The Hood

Architecture Colanode uses a strict monorepo topology managed by Turborepo, with domain logic distributed across independently versioned packages: @colanode/core holds domain types, typed ID generation via ULID, and CRDT document schemas; @colanode/crdt wraps Yjs into an ergonomic API with undo/redo support; @colanode/client implements a Mediator pattern — all data access routes through typed QueryHandlerMap and MutationHandlerMap registries, preventing any UI layer from touching databases directly. An EventBus propagates domain events through layers on both client and server, while typed Synchronizer classes on both sides manage incremental CRDT state exchange over WebSockets. The three app targets (Electron, PWA, React Native/Expo) consume identical client-layer logic, differing only in filesystem and SQLite bindings.

Tech Stack The server runs Fastify with fastify-type-provider-zod for end-to-end request validation, Kysely for fully type-safe PostgreSQL queries, and Pino for structured logging. Redis (Valkey-compatible) handles WebSocket pub/sub and ephemeral socket state. On the client, Kysely handles local SQLite queries (via better-sqlite3 in Electron, expo-sqlite on mobile, and OPFS-backed SQLite in the browser), while Yjs powers collaborative editing and Tiptap/ProseMirror provides the block editor. Browser clients run all SQLite work inside a dedicated web worker via Comlink, keeping the UI thread free. Build tooling is Turbo + Vite/tsup, with Electron Forge for desktop packaging and Expo for mobile.

Code Quality Server integration tests use Testcontainers to spin up real PostgreSQL and Redis containers, covering account management, authentication, file handling, mutations, and workspace APIs. Web tests are present and growing. TypeScript strict mode is enforced across the entire monorepo, with discriminated union types for all node kinds and domain-prefixed ULID IDs that prevent cross-entity reference errors at compile time. ESLint and Prettier are configured uniformly via shared configs. Error handling in the server is plugin-based through Fastify’s error handler mechanism, with Zod schemas providing runtime validation at every API boundary. Mobile app test coverage remains limited compared to the server layer.

What Makes It Unique The most technically distinctive aspect is running a full SQLite database inside the browser using the Origin Private File System (OPFS), processed in a dedicated web worker via Comlink — enabling true local-first collaboration without any browser extension or native binary. Combined with Yjs CRDTs that merge concurrent document edits without server mediation, the system achieves offline-capable, real-time collaboration that most web apps consider fundamentally incompatible goals. The shared @colanode/client package that runs identically on Electron, browser, and React Native is another rare achievement, requiring a filesystem abstraction layer that maps platform-specific APIs to a unified interface.

Self-Hosting

Colanode is released under the Apache License 2.0, a permissive open-source license that permits commercial use, modification, distribution, and private use without restriction. There are no copyleft obligations — you can integrate or modify Colanode for internal use or build products on top of it without releasing derivative work. No enterprise tiers, license keys, or feature gates exist in the current codebase; all functionality is available to self-hosters.

Running Colanode yourself requires maintaining three infrastructure components: PostgreSQL with the pgvector extension (for current vector storage scaffolding), a Redis-compatible service such as Valkey, and a file storage backend. The defaults use local filesystem storage, but S3, Google Cloud Storage, and Azure Blob Storage are configurable via environment variables. For production deployments, you are responsible for database backups, Redis persistence, storage replication, TLS termination, and rolling upgrades. The Kubernetes Helm charts and Docker Compose files reduce initial setup friction, but ongoing operational work — monitoring, scaling the server layer horizontally, managing Postgres connection pools — falls entirely on the operator.

The project currently offers a free cloud beta with EU and US regions at app.colanode.com, which serves as the easiest onboarding path. Pricing for cloud hosting has not yet been announced. Self-hosters receive no SLA, no managed upgrade path, and rely on community support via Discord and GitHub Issues. The roadmap suggests AI-assisted features (document embedding, assistant responses) are in early development — these will require pgvector and additional configuration when eventually enabled, adding another operational dependency for teams wanting those capabilities.