Take-Home Assignment: Real-Time Live Quiz App
Stack: MERN (MongoDB · Express · React · Node) | Time budget: ~2 working days | Due: Friday, June 12, 2026 —
5:00 PM
Overview
Build a small live, multiplayer quiz application (think Kahoot). A host launches a quiz; players join with a room
code and answer timed questions while a leaderboard updates in real time. We are not testing how many features
you can ship — we are testing whether you can build a correct, synchronized, real-time system. A small app that
gets the hard parts right beats a feature-rich one with race conditions.
The Product
1 A host creates a quiz (a set of multiple-choice questions, each with a time limit) and starts a game session.
2 Players join the session with a room code + nickname.
3 The host advances through questions. Every player sees the same question at the same time, answers before
the timer ends, then sees the correct answer and the updated leaderboard.
4 Repeat until the quiz ends and a final ranking is shown.
Core Requirements (required)
• Host flow: create a quiz, start a session (generates a room code), advance question → reveal → leaderboard →
next, end game.
• Player flow: join via room code + nickname, submit an answer within the time limit, see correctness and current
rank.
• Real-time sync: all state transitions are pushed live to every client (no polling for game state).
• Server-authoritative timing: the server owns the clock and the question lifecycle. Client-side timers are
display-only; the server decides when a question opens/closes and whether an answer arrived in time.
• Server-side scoring: correct answers earn points; faster correct answers earn more (define your own formula
and document it).
• Live leaderboard that updates after each question.
What We Are Really Testing (the hard parts)
Address these explicitly — they are the point of the exercise:
• Never trust the client clock. Timing and “did this answer count?” are decided server-side.
• Disconnect / rejoin: a player who drops mid-game and rejoins should land back in the running session with
their score intact.
• Late joiners & non-answers: handle players who join after start or never submit an answer.
• Multi-client consistency: many players stay in sync through every transition.
Technical Constraints
• MERN stack; real-time via WebSockets ([Link] or ws) — not HTTP polling.
• Persist quizzes in MongoDB (game results too, if you have time).
• Lightweight host auth is fine; players only need a nickname.
Bonus (only if time allows)
Reconnection recovery, multiple question types, persisted game history, simple anti-cheat (e.g. reject answers after
timeout server-side), or a deployed demo URL.
Deliverables
• Git repo (public or share access) with a sensible commit history.
• README — how to install, configure, and run locally.
• [Link] (½–1 page) — your data model, how you made timing server-authoritative, and how you handled
disconnects / edge cases, with tradeoffs.
• Short demo video (3–5 min) showing a host + 2 players, ideally including a disconnect-and-rejoin.
Evaluation Criteria
Weight What we evaluate
Critical Correct real-time sync & server-authoritative timing
Critical Edge-case handling (disconnect, late join, no answer)
High Code quality & architecture
High Design reasoning ([Link])
Bonus Tests for scoring / timing logic
Note on tooling: Using AI assistants is allowed. However, you should fully understand your code — expect a short
follow-up review where you will explain your timing / disconnect logic and make a small live change.
Submission
Send the repo link + demo video by Friday, June 12, 5:00 PM. Questions about scope or assumptions are welcome
— state any assumptions you make in your README.