A full-stack application where multiple users edit the same document simultaneously — powered by WebSockets, React, Node.js & MongoDB.
From the moment you type a character to when your collaborator sees it — here's the full journey.
Users sign up / log in via a REST API. The server issues a JWT token stored in the browser. Every request carries this token so the server knows who you are.
Notes are stored in MongoDB. When you open a note, the client fetches its content via a GET request and renders it in the editor. A unique room ID is assigned per note.
The moment you open a note, your browser establishes a WebSocket connection to the server and joins a "room" specific to that note. This keeps a live, two-way channel open.
When you type, your client emits a text-change event with the delta (just the change, not the whole doc) to the server. The server broadcasts it to all other users in the same room.
If two users type at the same moment, conflicts are resolved via Quill's built-in delta model (a simple OT approach) — ensuring both changes merge correctly without overwriting each other.
Every 2 seconds, the server debounces incoming changes and saves the latest document state to MongoDB. If the connection drops and reconnects, you always get the latest saved version.
Every tool chosen intentionally. Hover each card to see why it was picked.
Component-based JavaScript library for building the user interface. Handles routing, state management, and re-renders only what changes — keeping the editor fast even while receiving live updates.
JavaScript runtime that runs the server. Express adds a minimal web framework for defining REST API routes (login, signup, CRUD for notes). Node's event loop handles thousands of concurrent WebSocket connections without blocking.
A library that wraps WebSockets (with fallback to HTTP long-polling). Provides rooms, namespaces, and event-based communication. When Alice types, her delta is emitted to a room — only users in that room receive it.
NoSQL document database. Notes are stored as JSON documents — they don't have a rigid schema, so adding fields like "tags" or "version history" later is trivial. Mongoose provides schema validation and query helpers.
JSON Web Tokens are signed, stateless tokens issued on login. Stored in the browser (HttpOnly cookie or localStorage), they are sent with every API request. The server verifies the signature without needing a database lookup for every request.
An open-source rich text editor that represents document content as "Deltas" — a JSON-based diff format. Instead of sending the whole document on each change, you send just the delta (e.g., "insert 'h' at position 42"). This is the foundation of real-time sync.
Utility-first CSS framework. Instead of writing custom CSS classes, you compose styles directly in JSX using utility classes like flex gap-4 rounded-lg. Speeds up UI development dramatically.
GitHub Pages hosts the static React frontend for free. Render.com hosts the Node.js backend (also free tier). MongoDB Atlas provides a free cloud database. Combined, your full-stack app is live at zero cost.
Get a live shareable link for your resume in 4 steps. Frontend on GitHub Pages, backend on Render, database on MongoDB Atlas — all free.
Create a new repository, push your code. Name the repo collab-notes or anything you like.
In your React app, run the build command. Then use gh-pages package to push the build folder to the gh-pages branch.
Sign up at render.com → New Web Service → connect your GitHub repo → set build and start commands. Render auto-deploys on every push.
Create a free M0 cluster on atlas.mongodb.com. Copy the connection string and add it as an environment variable on Render.
Add this line under the project: "Live at [your-github-username].github.io/collab-notes — try editing simultaneously in two browser tabs." That single instruction shows recruiters exactly how to test your real-time feature in 5 seconds.
Check out the app itself, then come back here to understand every piece.
✏️ Open the App →