Projects / GroupSync

GroupSync: group chat that remembers who said they'd do what

A real-time collaboration app built for INFO2222. Messages sync between everyone in a group as they're sent, and an AI step picks out commitments from the conversation so they don't get buried.

Type
Web app, university project
Stack
Next.js, Node.js, Socket.io, SQLite
Course
INFO2222, USyd
Focus
Real-time sync, persistence
Browsers connect to a Next.js server over Socket.io. The server writes to SQLite and calls a commitment detection step, then broadcasts to the group's room. Browser A Browser B Browser C Next.js serverpages and API routesSocket.io rooms, one per group SQLiteusers, groups, scheduling Commitment detectionAI step on new messages
One server holds the socket connections and is the only writer to the database.

What I built

  • The client-server contracts: which events exist, what each one carries, and who's allowed to send it
  • Real-time state sync with Socket.io events, so every member sees the same view without refreshing
  • The SQLite schema and data access layer for users, groups and scheduling
  • The pipeline that feeds group chat to the commitment detection step and turns its output into action items

How a message moves

  • A client sends the message over its open Socket.io connection
  • The server writes it to SQLite, so it survives a refresh or a dropped connection
  • The server broadcasts it to that group's room, and every connected member sees it straight away
  • The commitment detection step reads new messages and flags the ones where someone takes on a task

Why these pieces

Socket.io over plain WebSockets because it handles reconnects and has rooms built in, which maps cleanly onto groups.

SQLite because it's one file with no server to run, which suits a course project with a small number of users. The tradeoff is that it's built for one writer at a time.

Next.js because the pages and the API live in one codebase and deploy together.

What I'd change to run it for real

  • Move from SQLite to PostgreSQL once there's more than one server or a lot of concurrent writes
  • Add the Socket.io Redis adapter so rooms work across several server instances
  • Run commitment detection off a queue so a slow AI call never delays message delivery
  • Measure message delivery latency (p95 from send to receive) and treat it as the main SLI