OmniPad

Turn 100-Page PDFs into Active Recall in Seconds.

Comment

Inspiration

We set out to fix two fundamental flaws in how students interact with educational software.

First, standard study tools treat document length as a content problem rather than an architecture problem. When a student drops a 100-page syllabus into a conventional app, the UI blocks, the context window gets silently truncated, or the system chokes on background memory.

Studying shouldn't degrade just because a document is heavy.

Second, active recall in modern study wrappers is completely superficial. They display a flashcard, ask you to type a sentence, and let an LLM praise you for repeating textbook definitions. But memorizing jargon isn't understanding.

If you need words like "fluid displacement" or "gravitational vector" to explain buoyancy, you haven't mastered the concept—you've just memorized a glossary.

OmniPad was built out of both frustrations. A system where background processing is offloaded to queues, and where the evaluation engine actively penalizes domain jargon to enforce true conceptual mastery.

What it does

OmniPad turns raw study documents into interactive, voice-evaluated learning pipelines in seconds.

Module Processing Pipeline

Files are ingested, assigned a cryptographic SHA-256 filehash to prevent duplicate DB writes, and pushed immediately to an asynchronous background worker queue.

Feynman Reviewer

Uses the native browser WebSpeech API to capture live vocal explanations. The evaluation engine compares transcriptions against generated reference answers, explicitly failing any response that relies on high-level jargon.

Explain buoyancy like you're talking to a 10-year-old; drop a technical buzzword like "density," and the system rejects the explanation.

Socratic Questioning Engine

Forces the user out of surface-level memorization by asking targeted mechanism-driven "why" questions based on source document logic.

Quiz & Flashcards

Generates static multiple-choice sets and memory cards, cached locally and bound immutably to the original document hash to eliminate unnecessary refetches.

Session Lockout

Complete or failed sessions lock state upon reaching an 80% passing threshold, forcing students to commit to an attempt rather than endlessly re-rolling questions.

How we built it

We built OmniPad with a hard architectural rule: background processing must never block the client UI.

Queue Management via BullMQ & Redis

Document parsing, text chunking, and question set generation run entirely inside Redis-backed queues. A 100-page syllabus processes silently in the background while the UI remains at 60 FPS.

Immutable Data Pairing

Question sets and reference answers are immutably linked to specific file_id and session_id pairs in PostgreSQL upon initial extraction.

The LLM never generates the same content twice.

Client-Side Speech Parsing

We leveraged the native browser WebSpeech API for real-time speech recognition, feeding raw text transcriptions into the evaluation engine to bypass expensive audio-to-LLM streaming overhead.

Deterministic State Engine

Database updates order dashboard queues strictly by direct SQL queries (ORDER BY due_date ASC and ORDER BY updated_at DESC), completely avoiding synthetic "AI recommendation" layers.

Challenges we ran into

The "Jargon Reward" Prompting Paradox

Standard prompt engineering produced evaluation text that was far too forgiving. It routinely rewarded students who used complex-sounding domain vocabulary because the LLM recognized the terms as technically relevant.

We had to implement structural scoring constraints that actively penalize high-level vocabulary, forcing the engine to reward plain-language analogies over textbook quotes.

State Lockout vs. Cheap Retry Loops

Balancing user engagement with strict testing conditions required intentional state restrictions. Allowing users to reset active sessions created cheap retry loops.

We had to enforce hard locks on files marked "complete," forcing users to explicitly delete and re-ingest a file if they wanted to start completely fresh.

Asynchronous Pipeline Race Conditions

When a user uploaded a massive document and immediately clicked into the Feynman module, the frontend attempted to fetch session questions before the background queue finished extraction.

We solved this by implementing real-time webhooks that update the file status in PostgreSQL from processing to ready, keeping session triggers strictly disabled until the queue flushes.

Accomplishments that we're proud of

The dashboard has zero synthetic "AI Advice"

Every metric on the main page is backed by pure SQL.

The queue is ORDER BY due_date ASC, recently reviewed is ORDER BY updated_at DESC, and study velocity is a raw COUNT(files) over time. No fake recommendations.

Zero Re-fetches on 100-Page Documents

Once BullMQ processes a document, every question, flashcard, and reference answer is permanently tied to the file_id.

Opening a study session weeks later takes 0ms of generative processing time and costs zero API tokens.

Enforced Voice Simplicity

Integrating WebSpeech API forces students to speak their answers out loud without relying on text entry.

It immediately exposes the gap between passive reading and vocal explanation.

Hard Threshold Locks

Sessions require a strict 80% score to pass, and completed sessions lock state permanently.

We intentionally removed mid-test backward navigation to eliminate guessing and force focus during active evaluations.

What we learned

Mastery requires constraints, not praise

Standard AI study tools flatter the user by validating whatever they type.

Penalizing technical jargon turned out to be the single most effective feature for driving actual comprehension.

Async pipelines are mandatory for AI UX

Moving document parsing and chunking to BullMQ and Redis turned a blocking, sluggish web interface into a responsive system.

Strict state builds better habits

Preventing users from infinite retries or backward navigation within active tests forces higher focus during sessions.

The system works best when it refuses to be lenient.

What's next for OmniPad

Multi-Format Assessment Expansion

Expanding the Quiz module beyond basic multiple-choice to support dynamic identification, short-answer, and true/false matrices simultaneously.

Mathematical Memory Decay Modeling

Upgrading study velocity from raw upload counts to a memory retention decay curve, calculating retention probability R over elapsed time t via the exponential relation:

$$R = e^{-\frac{t}{S}}$$

where S represents the calculated strength of memory based on historical pass rates.

Transcribed Session History Audits

Adding full transcript review views in the History tab so students can read back their exact spoken explanations alongside the AI's structural critiques.

Project Overview

The Idea

OmniPad was inspired by two core flaws in educational software: standard applications choke when processing long documents, and active recall engines rely on superficial LLM praise for memorized jargon. OmniPad was created to enforce true conceptual mastery through queued background processing and jargon-penalized evaluation.

How It Works

Users upload study materials, which are immediately hashed using SHA-256 and offloaded to a Redis-backed BullMQ queue for asynchronous parsing, chunking, and question set generation. Once processed, students complete voice-evaluated Feynman reviews and Socratic questioning sessions. Transcriptions captured via the browser's native WebSpeech API are evaluated against reference logic, strictly failing responses that rely on high-level buzzwords rather than plain-language mechanics.

Main Features

  • Jargon-Penalized Feynman Reviewer: Captures vocal explanations via WebSpeech API and rejects responses relying on domain buzzwords to force plain-language conceptual mastery.
  • Asynchronous BullMQ Pipeline: Offloads heavy PDF extraction, chunking, and generation to background queues, keeping the user interface completely non-blocking.
  • Socratic Questioning Engine: Dynamically generates mechanism-driven "why" questions based on source document logic to target structural comprehension.
  • Deterministic SQL State & Threshold Lockout: Orders queues and dashboard metrics purely via SQL queries while enforcing permanent session locks upon reaching an 80% passing score.
  • Immutable Document Hash Pairing: Links generated sets to a cryptographic filehash, guaranteeing zero LLM re-fetches or redundant API calls on repeat sessions.

Technology Stack

  • Languages & Runtimes: TypeScript, Node.js
  • Frontend: React, Tailwind CSS
  • Backend & API: Express, Supabase (Storage & PostgreSQL)
  • AI & Inference: Groq API (Gpt oss 20b / Fast LLM Inference Engine)
  • Queue & Caching: Redis, BullMQ
  • Client-Side Capabilities: WebSpeech API
  • Database & ORM: PostgreSQL, Prisma

Intended Audience

OmniPad is designed for high school, university, and specialized STEM students who need to master dense technical documentation, syllabi, or complex subjects without hitting UI performance bottlenecks or relying on passive memorization.

Share this project:

Updates