Inspiration

Every spaced-repetition app tells you when to review. None of them tell you whether their schedule is actually any good. We wanted a study tool that treats memory like weather: forecast it, then check the forecast against what happened. The tagline in our head was "a 1986 weather station that forecasts your memory", which is also where the retro-futurist synthwave look comes from.

What it does

Forgetting Forecast estimates the probability that you'll remember each concept, shows you what is about to fade, and then audits itself.

  • Memory Weather dashboard: predicted recall per concept, rolled up to topic and subject.
  • Keyboard-driven review workspace: answer, rate your confidence 1–5, and the model updates.
  • Immutable forecast log: after every review we log 1-day, 7-day and 30-day forecasts. They are insert-only and later scored against real attempts.
  • Honest analytics: Brier score, reliability bins, immediate vs. delayed accuracy, and a comparison against simple baselines. Every metric shows insufficient data below 10 observations. We never invent numbers.
  • Study material to quizzes: upload a PDF, PPTX, DOCX or TXT (or paste a YouTube link). The app extracts terms and definitions with rules, not an LLM, and generates cloze, multiple-choice, true/false and numerical questions. Every question cites its source ("DBMS Notes, p. 12").
  • Mixed tests, a prerequisite graph and exam plans: interleaved tests weighted towards fading concepts, and a day-by-day revision plan ending in a mock test.

How we built it

The core is an exponential half-life model:

$$P(\text{recall at } t) = 0.5^{\,\Delta t / h} \cdot d$$

where \(\Delta t\) is hours since the last review, \(h\) is the estimated half-life, and \(d\) is a difficulty adjustment. After each attempt the half-life is updated:

$$h' = h \cdot f_{\text{outcome}} \cdot f_{\text{speed}} \cdot f_{\text{confidence}} \cdot f_{\text{difficulty}}$$

The stack is Next.js 15, React 19, TypeScript, Tailwind 4 and Supabase (Postgres, Auth, Storage). It has four layers: route, service, repository, domain. The domain layer is pure functions with no I/O, shared by the server and the UI, and covered by unit tests.

Design decisions we're proud of:

  • Predictions can't be forged. The probability stored with each attempt is computed on the server from the stored state before the outcome is applied.
  • Atomic, idempotent reviews. One Postgres transaction (submit_review_tx) writes the attempt and the recall state. A retried clientRequestId writes nothing twice.
  • Security by default. Row-level security on every table, and RPCs run as the caller (SECURITY INVOKER). We wrote a test where two throwaway users try to read each other's data.
  • Challenger model. A feature-adjusted model is evaluated walk-forward against v1 and the baselines in Model Lab. It is evaluation-only and never drives scheduling.

Challenges we ran into

  • Not fooling ourselves. It's easy to make a forecast look good. We had to make evaluation leak-free: baselines use only past attempts, with no look-ahead, and delayed outcomes are matched inside a ±50%-of-horizon window.
  • Rules instead of an LLM. Pulling usable terms and definitions out of messy PDFs and slides with pattern matching means some terms are missed or mis-detected. We show the source sentence for every term so you can check it.
  • Grading free-text answers. Word overlap plus edit distance is a heuristic, so every automatic grade has an override step before it is saved.
  • Brittle inputs. YouTube captions come from an undocumented page structure that can break. Scanned PDFs fail with a clear message because there is no OCR.

What we learned

  • Calibration matters more than accuracy: a forecaster that says "80%" should be right about 80% of the time.
  • Honest empty states ("insufficient data") build more trust than a polished chart built on nothing.
  • On our shipped demo seed, the half-life model does not beat the "your past accuracy" baseline, and the Analytics page says so. Building a tool that reports its own failure turned out to be the most interesting part.

What's next

FSRS as a stronger scheduler, wiring the target recall setting into scheduling, fitting the model on real learner data, OCR for scanned PDFs, an offline mode, and a shared rate limiter (Redis/Upstash) for multi-instance deploys.

Note: The demo account holds simulated sample data, clearly labelled SAMPLE DATA throughout the UI.

Built With

  • claude
  • opencode
Share this project:

Updates

Submission history