Web

Collaborative Whiteboard with Conflict-Free Sync

A multi-user drawing surface where several people edit at once, changes merge without a central lock, and everything still converges after someone works offline and reconnects. The value is in implementing the sync algorithm rather than importing one.

Difficulty

Advanced

Needs a team, real planning, and a supervisor who knows the area.
Effort

1 semester, 2 to 3 students

Deliverables

5 to ship

3 optional extras

Suggested stack

TypeScriptReactCanvas APIWebSocketNode.jsRedis
A suggestion, not a requirement. Swap anything for what you already know.

What you should ship

  • Canvas editor supporting shapes, freehand drawing, text and selection
  • A conflict-free replicated data type implemented from scratch for the document model
  • WebSocket sync layer with presence and live cursors
  • Offline editing with correct convergence after reconnection, demonstrated under deliberate partition
  • Automated convergence test applying randomised concurrent operation sequences and asserting all replicas match

If you have time left

  • Undo that is per user rather than global
  • Snapshot compaction so long lived documents do not grow without bound
  • Export to a standard vector format

The problem

Real time collaboration looks simple and is not. Two users editing the same object concurrently must end in the same state on every device, without a server arbitrating every keystroke and without either user losing work.

What you build

The document model as a conflict-free replicated data type, a sync layer over WebSockets, and an editor on top. The editor is the least interesting part and should be kept deliberately modest.

Why implement the algorithm yourself

Importing a library reduces this to a drawing application with a websocket, which is not a final year project. Implementing the merge semantics, proving convergence and testing it under adversarial conditions is the contribution.

The test that makes the project

A randomised convergence test. Generate long sequences of concurrent operations across simulated replicas in random orders with random partitions, apply them, and assert every replica reaches an identical state. When this passes reliably over thousands of runs, you have a real result to report.

The hard part

Ordering and identity. Deciding what happens when one user deletes an object while another moves it, and making that decision consistent everywhere, is where the design work is.

Scope warning

Keep the drawing tools minimal. Rectangles, freehand, text and selection is enough. Every hour on drawing features is an hour not spent on sync, which is what is being assessed.

Ideas and guidance, not finished projects

These are project ideas and scoping guidance, published free for students to use as a starting point. I do not build, write, or sell final-year projects, and I do not complete coursework for anyone. Take an idea, make it yours, and build it.

Not sure this one fits you?

I help students pick an idea that matches their skills and their deadline, then scope it down until it is finishable. Guidance only, never done for you.

Get guidance
Work with me

Stuck on something specific?

Writing only gets you so far. If you want an answer to your situation rather than the general case, book a session and we will work through it together. Every session is free; a few slots open each week.

Follow along

New writing, resources and project ideas land here first.