Tutor — Full-Featured SAT/GRE Mock Examination Platform with Anti-Cheat Architecture

An independent tutor preparing students for SATs and GREs faced a frustrating reality: every off-the-shelf mock examination platform fell short in critical ways. The enterprise solutions (Kaplan, Princeton Review) were prohibitively expensive for an independent operator — quoting $150,000+ for custom platforms. The affordable options could not handle the specific requirements of high-stakes standardized tests.

Those requirements were substantial. Reading comprehension sections demanded long passages displayed side-by-side with questions, with precise highlighting and passage-referencing that had to be interactive and pixel-accurate. Mathematics sections required full LaTeX rendering — every equation, formula, and notation had to render correctly across devices. Exams had to be timed with server-authoritative enforcement — no client-side manipulation possible. Question types were wildly varied: multiple choice, numeric entry, passage-based reasoning, quantitative comparison, and multi-step problems.

The tutor's business depended on offering a realistic test experience. Without a proper platform, students were practicing on static PDFs — no timing pressure, no interactive feedback, no simulation of actual test conditions. The gap between practice and reality was hurting student performance on test day.

We were early-stage ourselves at this point — no existing exam platform, no pre-built components to draw from. Every sub-problem required independent research, prototyping, and careful integration of open-source pieces stitched together with custom glue code. There was no enterprise platform buy-in. No expensive licensing. Just focused engineering against a well-understood problem domain.

Our approach was to decompose the exam experience into its fundamental components — passage rendering, math notation, timing enforcement, question state management, scoring logic — and solve each one independently before integrating them into a seamless experience. The architecture was designed to be exam-agnostic from the start: the same platform that handled SATs could be adapted for GREs, GMATs, or any other standardized test with configuration changes, not code rewrites.

The platform was built around five core engineering challenges, each solved independently and integrated into a unified experience:

1. Split-Pane Reading Interface: The reading section required a side-by-side layout — passage on the left, questions on the right — with synchronized scrolling so that as the student scrolled through the passage, the question pane followed. Highlight annotations had to map back to precise passage text positions and survive re-renders when questions changed. We built a custom split-pane component with bidirectional scroll sync and a text-position-mapping layer that tracked highlights as offsets, not DOM positions — ensuring accuracy even after text reflow.

2. LaTeX Math Rendering Pipeline: Math notation is notoriously difficult to render consistently across browsers and devices. We evaluated multiple rendering engines (MathJax, KaTeX, custom SVG pipelines) and settled on a hybrid approach: server-side pre-rendering for static equations with client-side fallback for interactive elements. The pipeline handled both inline equations (integrated into text flow) and display equations (standalone with proper spacing). Cross-device testing covered 12 browser/device combinations to ensure rendering consistency.

3. Server-Authoritative Timer & Session Enforcement: This was the most critical integrity feature. The timer authority lived on the server, not the client. A heartbeat system synced remaining time at frequent intervals while keeping the UI responsive — no page reloads, no visible sync. Session management detected tab switches, window blurs, and navigation attempts with configurable strictness settings: warn on first offense, log all violations, or terminate the exam after a threshold. All violation events were recorded in the exam audit log for review.

4. Question Engine & State Management: The exam format included multiple question types — multiple choice, numeric entry, passage-based, and quantitative comparison — each with different interaction patterns and scoring rules. We built a state machine that tracked answered, flagged-for-review, unanswered, and currently-active states for each question. Navigation between questions was fluid with keyboard shortcuts for power users. A review screen showed all questions with status indicators, allowing students to jump directly to flagged items before submission.

5. Grading & Analytics Engine: Automated grading with partial credit rules configurable per exam type. Results included section-level breakdowns, time-per-question analytics, and performance comparisons against historical averages. Students could review their answers alongside correct responses with explanations — turning every mock exam into a learning opportunity.