Working references I keep for revision and interview prep — drafted once, returned to often.
Organised by subject and built for fast recall. Pick a shelf below, or jump straight to a sheet.
Java
05 collections · 22 chaptersLanguage Fundamentals
The object model and the modern language on top of it — the four pillars with the keywords that express them, then what Java 8 changed: lambdas, functional interfaces, method references, and the Streams API as a way of describing a computation rather than stepping through one.
Open collection 02Design & Patterns
Designing classes other people can live with. The Object contract and equals/hashCode first, then ordering with Comparable and Comparator, the SOLID principles in full, UML for the low-level design round, and the creational patterns — factory method, builder, singleton — as answers to problems rather than trivia.
Open collection 03Data & I/O
Getting data in and out of a Java process. Files and streams, JDBC with the transaction semantics underneath it, JSON binding through Jackson, and HTTP as a client — REST conventions and RestTemplate.
Open collection 04Concurrency
One job, one lane — and everything that goes wrong once there are several. Threads and the lifecycle first, then the synchronisation primitives that keep shared state honest, and finally thread pools and ExecutorService, where you stop creating threads by hand.
Open collection 05Spring Boot Framework
The container that wires your objects for you. Starting from why inversion of control matters, then dependency injection in practice, what a REST backend actually does beneath the annotations, testing with mocks and test doubles, Spring Data JPA from object to table, and MongoDB when rows stop fitting.
Open collectionSQL
01 sheetDSA
06 collections · 21 chaptersFoundations
What you need before the first problem. The Java subset that actually shows up in contests and interviews, strings and fast input handling, then the two pieces of maths that quietly underpin half of everything — modular arithmetic and counting.
Open collection 02Linear Structures
The four structures that carry most of the problem space, each as a worked problem set rather than an API tour — strings, stacks, queues and heaps, with the pattern each one exists to serve.
Open collection 03Search & Recursion
Finding things, by narrowing or by trying. Hashing for constant-time lookup, binary search as a way of thinking rather than an array trick, and backtracking for the problems where you have to explore and undo.
Open collection 04DP & Greedy
The two strategies people find hardest to start. Dynamic programming three ways — an introduction, the recursion-first route that makes memoisation feel inevitable, and a full masterclass — then greedy, and how to tell when it is actually safe.
Open collection 05Graphs & Structures
The structures with shape. Tries for prefix work, matrices as a data structure in their own right rather than a nested loop, and graph algorithms across fourteen problems — traversal, shortest paths, and the ones that only look like graphs afterwards.
Open collection 06Practice Trackers
Problem sets to work through rather than read — de-duplicated, ordered as a learning path, each row tickable with hints and a link out to a solving platform. Trees, dynamic programming and greedy.
Open collectionReact
08 sheetsReact Foundations
From first principles to live data — createElement, JSX, Babel, components, props, keys, useState, useEffect, Virtual DOM, reconciliation, CORS, shimmer UI, and controlled inputs.
Open sheet 02Foundations · Part II
Finding the path — client-side routing, dynamic pages, the effect-dependency rules, custom hooks, and keeping data fresh as the app grows.
Open sheet 03Netflix GPT — Build Log
Shipping the thing — scaffolding the app, auth and protected routes, Redux Toolkit state, and a GPT-powered search backed by a movie API.
Open sheet 04DevTinder — Build Log
Building to ship — a developer-matching app: routing and layout, auth and protected feed, and a clean separation between UI and data.
Open sheet 05The Machine Coding Round
An interview playbook for the 2-hour frontend build — how to clarify, plan, and structure components under time pressure without freezing on the prompt.
Open sheet 06Senior Frontend — Interview Round 1
The screening technical round, end to end — self-intro and work-experience stories, JavaScript / TypeScript / React Q&A, design patterns, a migrations & tooling deep-dive (React 16→18, webpack→Vite, TS 3.8→5.9), and live-build tasks (typed localStorage, RBAC, debounce) with full answers.
Open sheet 07Round 1 — Night-Before Cheat Sheet
The one-page spine of the Round 1 note — story hooks, the one-liners that land, high-yield JS/TS/React facts, migration principles, and live-build cues. Glance, don't study.
Open sheet 08Round 1 — Mock Interview
A timed, phased self-drill — 24 questions across intro, JS/TS, React, migrations, and a live build. Answer aloud first, then reveal what a strong answer hits and how they'll push. Built-in timer.
Open sheetFrontend System Design
01 sheetJavaScript
01 sheetPython
01 sheetAI & Retrieval
05 collections · 16 chaptersFoundations
The everyday Python toolkit the rest of these notes assume — the subset you actually reach for when writing retrieval and agent code.
Open collection 02Retrieval
Getting the right context in front of the model. Hybrid search combining BM25 lexical scoring with FAISS dense vectors and rank fusion, then the shift to Text-to-SQL when the answer needs arithmetic over rows, and a multi-source system that routes between both.
Open collection 03Knowledge Graphs
Retrieval over structure instead of similarity. What a knowledge graph buys you over chunked vectors, the primitives and Neo4j underneath Graph RAG, and how to get from raw text to entities and relations in the first place.
Open collection 04Agents & LangGraph
Where linear pipelines stop working and a system has to decide. Compiled graphs and the tool-calling contract, state machines and execution graphs, the ReAct architecture, persistence and threading, memory across turns, and the guardrails that keep it all in bounds.
Open collection 05DSPy
Programming language models instead of prompting them — signatures, modules and optimisers, and what it looks like when the prompt becomes a compiled artefact.
Open collectionProjects
09 buildsGymTrack — Guided Build
A from-scratch workout tracker mirroring QMoney's architecture on the free wger API. Eight modules across two parts: JSON parsing, REST & comparators, interfaces & Progressive Overload, then library packaging, publishing, failover, typed exceptions and multithreading.
Open build 02GymTrack — Persistence (M9–M11)
The continuation: from an in-memory app that re-reads JSON every run to a durable, database-backed product. A real MySQL store, a clean JDBC data-access layer, and a transactional write path that never leaves half-saved data behind.
Open build 03Notes-RAG — Build-Along Guide
A from-scratch RAG engine over these very study notes — structure-aware chunking, a swappable embedder/LLM seam, FAISS + cross-encoder reranking, grounded generation with citations, a FastAPI + Next.js app, retrieval evaluation, Docker, and a GitHub Action that reindexes on push.
Open build 04AI Learning Assistant — Guided Build
A build-it-by-hand walkthrough of an advanced RAG assistant — upload a PDF, ask by text or voice, get answers grounded in it with page citations. Built inside-out and runnable at every milestone: a walking skeleton first, each service written and tested before the route that uses it, main.py grown one router at a time. Multi-engine PDF extraction, local embeddings, FAISS + cross-encoder retrieval, RAGAS eval, Docker & CI — behind a pluggable LLM seam with Anthropic Claude as the primary provider.
Open build 05Brewline — LLD in Java, Pattern by Pattern
A build-along guide to Low-Level Design in plain Java, no framework. Grow a coffee-shop ordering & fulfillment engine and earn every Gang-of-Four pattern — Builder, Factory, Singleton, Decorator, Composite, Adapter, Facade, Strategy, State, Observer, Command, Chain of Responsibility, Template Method, Visitor — each starting from a real code smell, all under the discipline of SOLID.
Open build 06Loreplay — An AI Story-Narrator You Can Play
A build-along guide to an interactive story-narrator. Upload a book you own; it extracts the cast, relationships, and plot spine, then lets you inhabit any character — Neville instead of Harry — and play the story from their side. Canon and personalities hold, but events bend around your choices. RAG, structured extraction, a knowledge graph, persona modeling, a governed turn loop, multi-agent direction, and LLM-judge eval — on Claude behind a provider seam.
Open build 07Questling — An Isekai Habit RPG Run by an AI Guide
A build-along guide to a cozy habit-builder where your real to-dos become warm adventurous quests and an AI Guide named Lumi runs the whole board. Two engines — a task-to-quest Quest-smith (structured output) and a tool-calling Guide agent — plus a fair deterministic economy, skill-tree training arcs, adaptive difficulty, ethical gacha, narrative quest-letters, wellbeing guardrails, and LLM-judge eval. Claude behind a provider seam, FastAPI + Postgres, and a warm anime-village Next.js UI.
Open build 08Xlido — CLI Live Q&A Platform
A command-line Slido clone — users create events, post questions, upvote (once, no double-voting), and reply. The real goal is a well-designed, scalable Java application: four entities (User · Event · Question · Reply), SEBER layered architecture, the Command Pattern for dispatch, and eight operations with exact I/O contracts verified against expected output.
Open build 09Folio — Indian-Market Research Assistant
A from-scratch build-along guide to a personal investing-research app that reads concalls, annual reports, DRHPs and news, and produces decision briefs — bull case, bear case, what changed, and the flags — never a buy/sell verdict. Numbers are computed in code, never recalled, and every one cites its source under a numbers-audit. Twelve self-contained milestones that land the agentic course topics: intent routing, hybrid retrieval, cross-encoder reranking, a deterministic numbers layer, citation-first synthesis, a ReAct agent, a supervisor of bull/bear/flags analysts, RAGAS eval, plus GraphRAG, Text-to-SQL and DSPy appendices. Claude behind a provider seam.
Open buildSystem Design
03 collections · 28 chaptersBuilding Blocks
The individual pieces, one sheet each — how packets actually get there, the gateway and load balancer in front of everything, what CAP really constrains, queues and locking, SQL versus NoSQL with partitioning and indexing, and the three ways services expose an API.
Open collection 02System Design Foundations
A full course, built from the ground up: where each component physically lives, how a browser reaches a backend, then scalability, high availability, load balancing and the monolith-to-microservices spectrum. Databases, caching, queues and stream processing follow, closing on worked case studies and how to actually pick your tech.
Open collection 03Distributed Systems at Scale
The sequel, where one machine stops being enough. Concurrency and isolation when two users grab the last copy, splitting a database across shards, and transactions that span them — then eight services built for real load: live sports streaming, video on demand, feeds and notifications, content search, payments, and the mesh that wires them together.
Open collectionByteByteGo
04 courses · 41 chaptersSystem Design Interview — HLD
The full high-level design course in one reader. Foundations first (scaling a single server to millions, back-of-the-envelope estimation, the four-step interview framework), then the reusable building blocks — rate limiter, consistent hashing, key-value store, ID generator — then nine case studies from URL shortener to YouTube, Google Drive and proximity search.
Open course 02Object-Oriented Design — LLD
What the low-level design round actually grades, a repeatable four-step framework for getting from a vague prompt to a defended class diagram, and the OOP + SOLID groundwork underneath. Then eleven worked problems — parking lot, vending machine, elevator, ATM, blackjack, restaurant — each one a different design pattern in disguise.
Open course 03Generative AI System Design
Designing the whole machine, not just the model — what changed to make generative AI work, and a seven-step framework for the GenAI design interview. Then seven end-to-end case studies across three modalities: Smart Compose, Translate and ChatGPT for text; image captioning and RAG where two modalities meet; then GANs for faces and a VQ-VAE tokenizer for high-resolution synthesis. Each one carries its own data pipeline, decoding strategy, evaluation metric and serving path.
Open course 04Mobile System Design
The same interview, moved to the client — what a mobile design round actually measures at each seniority level, a five-step framework for keeping a deliberately open-ended prompt on the rails, and a full worked case study: an offline-capable, infinitely scrolling news feed for 500M users.
Open courseFinance
02 courses · 18 chaptersIntroduction to Stock Markets — Varsity
The whole first module in one reader. Why idle cash loses to inflation and the four asset classes, then the funding ladder from angels to IPO with the DRHP checklist that decides whether to bid. After listing: what moves a stock minute to minute, the index and free-float weighting, the trader's vocabulary and the terminal itself, and finally where your shares actually go — clearing, settlement, and the five corporate actions.
Open course 02Technical Analysis — Varsity
Reading price instead of the balance sheet. What TA assumes and where it breaks, the candlestick as a session's argument, then the pattern vocabulary — Marubozu and Doji through engulfings, Harami and the three-candle stars. Support and resistance finally supply a target, volume supplies belief, and the indicators follow: moving averages, RSI, MACD, Bollinger, Fibonacci. Closes on the Dow Theory, risk-reward, and a repeatable daily scan.
Open course