Interview Practice

A LeetCode-style website for practicing software engineering interviews: coding problems with a real editor and hidden test cases, pattern lessons, and system design books.

Live: https://interview-practice-sandy-eight.vercel.app

Features

• Problems: every coding problem from the Grokking pattern course, plus curated and company lists (Blind 75, NeetCode 150, Grind, CTCI, BCTCI, SQL 50, Concurrency, Object-Oriented Design, ML Coding and company lists), with difficulty, pattern and status filters.
• Workspace: problem description, worked solution and your submission history on the left; a Monaco editor (Python 3, Java, JavaScript, TypeScript, C++ or Go) and a Testcase / Test Result console on the right.
• Hints and complexity check: hints reveal one step at a time (topics, pattern, approach), and you state the time and space complexity before comparing with the reference.
• Run checks your code against the sample cases and any cases you add or edit (expected output comes from a tested reference solution).
• Submit checks it against every case, including hidden edge cases, and reports Accepted, Wrong Answer, Runtime Error, Compile Error or Time Limit Exceeded.
• Patterns: the course lessons, with diagrams, math and highlighted code in both languages.
• Practice: timed mock interviews drawn from any list (walkthroughs stay hidden until the round ends, followed by a self-rated debrief), a spaced-repetition review queue for solved problems, and a 16-week study plan. Mock rounds finish automatically at their deadline, including after a reload or device sleep; late submissions do not count toward the round. Interview mix fills from the remaining questions when a list has only one difficulty.
• Interview Guides: system design books plus focused practice for low-level design, AI architecture, testing and debugging, and behavioral interviews.
• Business Analyst prep (/business-analyst): a 14-chapter course for BA roles (requirements, elicitation, process modeling, Agile, testing, SQL and Excel, KPIs, Lean Six Sigma, banking and finance, interviews). Lessons are shown one at a time; each chapter ends with a 10-question quiz drawn at random from a bank of about 30, with shuffled answers and instant explanations. A score of 80% passes a chapter, but every chapter stays open whether or not its quiz is passed; taking all 14 quizzes unlocks a 30-question final exam. Includes a first-visit tour, a tip of the day, private per-chapter notes and a 39-session beginner study plan and a separate advanced Senior BA track with eight interactive chapters, quizzes, a 30-session plan and a capstone.
• Search and navigation: Ctrl/⌘ + K (or /) opens a site-wide search across problems, lists, lessons and guides; /problems groups study plans, topic tracks and company lists with per-list progress.
• Light and dark themes with low-glare colors, keyboard shortcuts (Ctrl/⌘ + ' to run, Ctrl/⌘ + Enter to submit) and progress saved in the browser.

How code runs

Language	Where	Notes
Python 3.13	In the browser, with Pyodide in a Web Worker	No server needed. The first run downloads the runtime (about 10 MB); later runs are instant.
JavaScript, TypeScript	In the browser, in an isolated QuickJS WebAssembly interpreter inside a Web Worker	TypeScript is transpiled in the worker by the TypeScript compiler, downloaded on first use; type errors do not block a run, as on LeetCode.
Java 21, C++17, Go	/api/run/<lang> on Vercel, inside a Vercel Sandbox microVM	Booted from one snapshot with the JDK, g++ and Go installed, no network access, 10 second run limit. About 5 seconds per run.

Every language uses the same test data. JavaScript, TypeScript, C++ and Go cover problems built from the core types (numbers, strings, arrays, lists, ListNode, TreeNode, Interval) and design classes, which is about 96% of the problems; the rest, which need graph nodes, interactive APIs or codecs, offer Python and Java. A problem's spec (content/problems/<id>.json) declares the signature and test inputs. The site generates a harness for each language that converts JSON inputs into typed arguments (including ListNode, TreeNode and Interval), calls your Solution, and prints JSON results. Outputs are compared in TypeScript, with order-insensitive checks and validators for problems that have several correct answers.

Back up practice data

Code drafts, progress, submissions, review queues, mock interviews, preferences, and last-opened pages are stored in this browser. Without an account they stay in that browser only, and clearing site data removes them. Signing in at Account & sync saves them to your account automatically and keeps every signed-in device up to date; see Accounts and progress sync. Open Back up or restore practice data in the footer of a browsing or reading page and choose Export backup to download a JSON copy. To restore it, choose the backup file, inspect the confirmation, and select Restore backup. Matching records are replaced while unrelated records remain, so export the current data first when keeping both versions matters. Backups are limited to 20 MiB and remain on your device.

Getting started

Requirements: Node.js 22+, Python 3.12+ (for generating test data), and for Java locally a JDK 17+ on your PATH.

npm install
npm run dev

Open http://localhost:3000. In development, Java, C++ and Go run with your local javac, g++ and go unless CODE_SANDBOX_SNAPSHOT_ID is set.

Content

Content is plain JSON in content/, generated from source files and committed to the repo.

Coding course

npm run ingest:grokking -- "/path/to/Grokking the Coding Interview folder"

This parses the saved Educative pages (one copy per language tab), keeps the Java and Python code, re-renders math with KaTeX and extracts diagrams to public/course-assets/.

Test cases

Each problem has a spec and a Python reference solution in content/problems/:

• <id>.json: signature, comparison mode and test inputs ("sample": true marks the visible cases)
• <id>.py: reference solution used to compute expected outputs
• <id>.java (optional): Java reference used to verify the Java harness

npm run tests:build              # fill in missing expected outputs and verify the rest
npm run tests:build -- --java    # also compile and run the Java references
npm run tests:build -- --langs   # also run JavaScript, TypeScript, C++ and Go references (<id>.js/.ts/.cpp/.go)
npm run tests:build -- some-id   # only some problems

Company lists

Company lists (Meta, Google, Amazon, Apple, Microsoft, Uber, NVIDIA, OpenAI, Anthropic) combine dated LeetCode tag snapshots, retained workbook entries and reviewed website reports. Recency buckets refer to the displayed snapshot date, not today. The latest upstream snapshot checked on October 13, 2026 is dated July 12, 2026. Original workbook entries remain available; rows absent from the selected snapshot buckets are labeled with their unknown date.

python3 scripts/ingest/company_lists.py <snapshot-dir> nvidia=NVIDIA openai=OpenAI anthropic=Anthropic
python3 scripts/ingest/company_crawler.py --cache /tmp/company-crawl > /tmp/discovery.json
python3 scripts/ingest/problem_sets.py Interview_Prep_Plan_ENRICHED.xlsx

The crawler stores facts only (problem, company, how many sources mention it), honours robots.txt, rate-limits each host and skips login or paywalled pages. LeetCode tags and exact, visible 1point3acres coding-list links are verified for extraction. The other three websites require manual review; explicit --sources opts into discovery. A whole catalog title must match a 1point3acres question link unambiguously: guide prose and longer variants never count.

Live runs always print discovery JSON to stdout and cannot overwrite the reviewed report. Caches expire after 24 hours; --cache-max-age 0 forces fresh requests, while --offline replays cached pages without changing their retrieval dates. Denied or rate-limited robots responses block the host. No cookies or credentials are sent.

The October 13 source review adds 1,076 company-list entries, records 59 website observations on 57 company/problem pairs, and adds a runnable recipe-dependency exercise. It builds on the October 12 refresh. interviewDB remains checked but unmapped where public titles do not identify a precise problem contract.

To reproduce this reviewed refresh without a network crawl:

python3 -B scripts/ingest/problem_sets.py Interview_Prep_Plan_ENRICHED.xlsx
python3 -B scripts/ingest/company_crawler.py --reviewed
python3 -B scripts/ingest/problem_sets.py Interview_Prep_Plan_ENRICHED.xlsx

company_report_observations.json preserves exact source links, retrieval dates and source-reported last-asked labels where available. --reviewed imports the complete manifest offline and retains evidence even for problems already in a snapshot. A filtered --reviewed run requires --dry-run; it cannot erase other companies or silently truncate the saved manifest. Expand Sources and dates on a table row to inspect its evidence. “Website reports” does not assert that undated interviews happened recently.

System design books

The Interview Guides section is a read-only reader: pick a collection, then a chapter from the contents on the left. The original practice collections are maintained as Markdown sources under scripts/ingest/ and imported into content/system-design/. They include worked exercises for parking lots, elevators, vending machines, task schedulers, retrieval-augmented generation, bounded assistants, incident diagnosis, SLO alerting, and behavioral stories, plus:

• System Design Case Studies: payments, job scheduling, collaborative editing, leaderboards, a matching engine, ad click aggregation, metrics, object storage, hotel booking, a distributed cache, email, global rate limiting and real-time pedestrian intent.
• AI-Assisted Coding Interviews, CS Fundamentals, Frontend Interviews, and Resume, Job Search and Offers. Each book is imported once into content/system-design/<book>/ (an index.json plus one Markdown file per chapter).

python3 -m pip install pdfplumber   # once; MIT-licensed PDF layout reader
npm run ingest:system-design -- grokking "./Grokking-the-system-design-interviewpdf-5-pdf-free.pdf"
npm run ingest:system-design -- advanced "./Grokking the Advanced System Design Interview.pdf"
npm run ingest:system-design -- notes "./Grokking the System Design Interview.md"   # Awesome-Senior-Engineer-Algorithms-Review

The Kafka chapters in the advanced collection include a version-scoped update for Kafka 4.0 and later, where ZooKeeper mode has been removed in favor of KRaft. The reviewed NeetCode 150 snapshot is stored in scripts/ingest/neetcode_150.json so workbook imports retain all 150 official entries while preserving existing slugs and saved progress.

The importer has layout rules per book: it rebuilds paragraphs and lists, keeps bold, italic and inline code, restores the ligatures the advanced PDF drops, and removes course boilerplate ("We'll cover the following", Back/Next links, page numbers) and inline URL dumps. Diagrams, including the advanced guide's vector drawings, are rendered from their page region into WebP files under public/course-assets/system-design/<book>/. The original document is published under public/course-assets/system-design/sources/ for download. It uses /usr/share/dict/words (present on macOS) to repair ligatures and hyphenation. The LibreOffice export of the classic course is the same text as the pdf-free edition, which is used because its diagrams and tables survive intact.

Business Analyst course

The course lives in content/business-analyst/ and is hand-authored:

• index.json: chapter order, titles, summaries, skill tags, quiz size, pass mark and final exam size.
• <chapter>.md: text before the first ## is the chapter introduction; every ## section is one lesson (keep each to about 1–3 minutes of reading, starting with a > **In short:** line).
• <chapter>.quiz.json: the question bank. Each question has lesson (the 1-based ## section it tests), q, four options with the correct answer first (choices are shuffled when shown), and why. Avoid positional options such as "all of the above".
• tips.json: tips shown in the tip-of-the-day card.

src/lib/ba-content.test.ts checks that every lesson is short and tested and every question is well formed. Progress, quiz attempts and notes are stored under the ip:ba:v1 key and are included in practice backups.

Deployment

The project deploys to Vercel; pushes to main deploy to production.

One-time setup for the Java, C++ and Go runner:

vercel link
vercel env pull .env.local          # provides VERCEL_OIDC_TOKEN for the Sandbox SDK
npm run sandbox:snapshot            # prints CODE_SANDBOX_SNAPSHOT_ID=snap_...
vercel env add CODE_SANDBOX_SNAPSHOT_ID production

An existing JAVA_SANDBOX_SNAPSHOT_ID keeps Java working; C++ and Go need the new snapshot. If a compiled-language runner is unavailable, users receive retry guidance and keep their draft; infrastructure errors do not count as failed submissions. Requests time out after 65 seconds. For operators, a 503 indicates missing snapshot configuration; a 502 requires checking the server logs and snapshot/toolchain availability. Sandbox usage is billed to the Vercel account. The run endpoint accepts only same-origin browser requests, but it is not authenticated; enable Vercel Deployment Protection if the site should be private.

Project layout

content/                  course lessons, problem specs, system design books (JSON + Markdown)
public/pyodide-worker.js  Python runner (Web Worker)
scripts/judge/js-worker.mjs  authored isolated JavaScript runner and TypeScript transpiler
public/js-worker.js       generated QuickJS worker bundle (npm run worker:build)
scripts/ingest/           course and document importers
scripts/judge/            expected-output generator and verifier
scripts/sandbox/          snapshot builder for the Java, C++ and Go runner
src/app/                  pages and the /api/run/[lang] route
src/components/           UI, including the problem workspace
src/lib/judge/            spec types, harness generators, grading and runners

Scripts

Command	What it does
npm run dev	Development server
npm run build	Production build
npm run lint	ESLint
npm run typecheck	TypeScript
npm test	Judge unit tests
npm run tests:build	Generate and verify expected outputs
npm run ingest:grokking	Import the coding course
npm run ingest:system-design	Import a system design book
npm run sandbox:snapshot	Build the Java Sandbox snapshot

The JavaScript worker is generated before development, production builds and unit tests. Submitted code runs in a fresh QuickJS context with no browser globals, networking or module loader; only output and a clock are exposed. The interpreter has a 128 MiB memory limit, and the page terminates the worker after 10 seconds. TypeScript is transpiled before execution.

Learning workspace

Open Practice or Today to find the complete learning workspace:

Route	What you can do
/practice/today	Choose coding, BA or mixed study; set a 30, 60 or 120 minute budget and dates; retain completed work in today's allocation.
/practice/notebook	Reopen saved lessons/sections and edit, schedule or resolve mistakes. Problem and lesson pages provide Save and Record a mistake controls.
/practice/readiness	Inspect accepted results, BA quiz passes, SQL checks, lab self-reviews and interview rubrics. Reading and self-assessment are labeled separately; these are not hiring predictions.
/practice/labs	Complete an end-to-end BA returns project and six senior decision simulations, use the beginner glossary/prerequisites and download three Excel practice/answer pairs.
/practice/labs/sql	Run twelve read-only SQLite exercises on fictional business data in a bounded browser worker, with schema, expected results and explanations.
/practice/interviews	Rehearse twelve authored system-design, BA and behavioral scenarios with persisted deadlines, follow-up prompts, saved answers, debriefs and anchored self-ratings.
/offline	Install the app where supported, explicitly download lessons, and manage the offline library. Only downloaded reading content is guaranteed offline; SQL/Python runtime downloads and compiled-language runners need a connection.
/settings/sync	Sign in with GitHub, Google or an emailed link; practice then syncs automatically across devices. Advanced tools compare snapshots and transfer one copy after a recovery download.
/content-status	Check real source/review/added dates, unknown dates, source links and recorded changes. Repository additions are not evidence of a recent interview.

Reading controls now include text size, line spacing, width, available device voices, speed, real pause/resume, paragraph highlighting and saved playback positions. Reader mode traps keyboard focus and returns it on Escape, right-click or visible exit. Appearance and reading preferences are included in backups; legacy palette preferences migrate on first visit. Voice availability and installation affordances depend on the browser/device.

A coding workspace's Start an independent attempt is a self-declaration before a fresh attempt. Hint and solution views stay attached to that attempt; a later reveal cannot rewrite a prior accepted result. Assistance outside the website cannot be detected. Existing accepted problems without tracked conditions remain unclassified.

All new learning data uses guarded browser storage and is included in the existing version 1 JSON backup. Restore validates the entire file before writing and preserves unrelated local records. Account sync uses this same validation and remains optional: it needs a Supabase project with the RLS migration and public deployment configuration; see Accounts and progress sync. Cloud writes use revision preconditions, and concurrent changes from several devices are merged rather than overwritten.

• Offline behavior and limits
• Authored labs, workbook generation and checks
• Content review conventions

CI runs unit/content checks, production/browser checks and four deterministic reference-verification shards in parallel. The final Quality checks job retains the existing required-check name and fails if any constituent job fails or is canceled. Shard tests verify complete, disjoint coverage; every Python/Java reference is still checked.

For browser verification use npm run build followed by CI=1 npm run test:browser. A local Chromium executable can be selected with PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH; by default Playwright uses its installed browser. Set TEST_OFFLINE_PRODUCTION=1 when running production offline checks locally without CI. The compiled-language browser checks require a configured sandbox in a production server; CI verifies their local harnesses separately.

Technical interview course

Open Interview Prep (/interview-prep) for 25 theory chapters and 100 beginner-to-advanced questions covering data structures, algorithms, Java, Spring Boot and object-oriented design. Each chapter includes a worked Java example, a walkthrough, time/space analysis with assumptions, an exercise and a solution. The contents page includes a suggested 25-session schedule and a Big O reference. Question banks support search and difficulty filters; chapters use the existing reader, bookmarks, mistake notebook and explicit offline downloads. References use Java 21 and Spring Boot 3.5 baselines, with version-specific notes where necessary. These are authored study materials rather than company-question reports.