To-do app inspired by Todoist and Google Tasks: lists sync across a person's devices using sync tokens, reads come from a cache, and pushes and reminders are sent in the background.
See why querying the database on every sync does not scale.
What was missing: A sync should not read all of a person's tasks from the database every time.
Why that's risky: Apps sync every few seconds, so the database re-reads the same unchanged lists thousands of times per second.
What gets added: One server that reads a person's tasks from the database on every sync and saves each change.
Trade-offs: Always current, but wasteful.
Separate syncing from saving and serve syncs from memory.
What was missing: Reads and writes share one path.
Why that's risky: Two devices can edit the same task, and an offline device can resend a change, so the system needs a conflict rule and a way to apply each change once.
What gets added: A sync service that returns only what changed since the device's last sync token, served from a per-user cache; a task service that saves changes; and a task database as source of truth.
Trade-offs: Last write wins is simple but can lose an edit; version checks catch the conflict but need client support. Todoist's sync API uses sync tokens and per-command ids for the same reasons.
Tell other devices about a change instead of making them poll, and send reminders off the request path.
What was missing: Other devices only learn about a change when they next poll, and reminders are not sent.
Why that's risky: Without push, every device polls every few seconds, which wastes battery and server capacity for lists that rarely change.
What gets added: Every saved change puts a job on a queue; workers push the change to the person's other devices, send due reminders and refresh the cache.
Trade-offs: Push makes changes appear in seconds, in exchange for running a notification path that can lag behind.
Protect the API from runaway clients and watch sync health.
What was missing: A buggy client stuck in a sync loop can overload the API, and nothing shows sync health.
Why that's risky: One misbehaving app version can send thousands of syncs per second from every install at once.
What gets added: A rate limiter per account and device, and monitoring of sync latency, push delay and queue depth.
Trade-offs: Limits can slow a legitimate bulk import, so writes get a higher allowance than repeated full syncs.
You're in the middle of an interview session. Leaving now will end your current attempt.
Explore concept overviews, real-system examples, key tradeoffs, and interview talking points for each roadmap section.
You've conquered this phase. These are the skills you now own: