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.
You have not recorded evidence yet. Start with the recommended Spring topic; the path will show your next meaningful action as you go.
Your progress is available for this visit only because browser storage is unavailable. Keep this page open or record your evidence elsewhere.
Your Spring path
Recommended start: Introduction to Spring Boot. Current milestone: Foundation. Next meaningful action: map a request from controller to response. Remaining core estimate: about 11 hours.
Your Spring interview path
Recommended start: Introduction to Spring Boot. Current milestone: Essential. Next meaningful action: explain dependency injection in 60 seconds. Remaining core estimate: about 5 hours.
Continue path Open Spring roadmap
Guided roadmaps: Java design · DSA foundations · AI foundations
Activity stays in this browser only.
Your study patterns
Once you switch modes, record evidence, or continue a path, this private summary will appear.
- Mode switches
- 0
- Evidence actions
- 0
- Path continuations
- 0
- Needs review
- 0
Guided paths now cover every generated course collection. Standalone shelves remain searchable and reader-first.
Java
06 collections · 39 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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, MongoDB when rows stop fitting, logging with SLF4J, and securing an API with Spring Security — Basic Auth through stateless JWT.
Guided path · Learn / Interview Open collection 06Spring Boot by Building
A practical Spring Boot workshop centered on TaskFlow: build endpoints, layers, persistence, tests, logging, DTO boundaries, relationships, transactions, Basic Auth, JWT, and then transfer the skill to guided sprints and capstones. Missions use acceptance checks, hints, and hidden reference patches instead of autograding.
Guided path · Learn / Interview Open collectionSQL
01 sheetDSA
07 collections · 18 editorials · 24 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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. Arrays, trees, dynamic programming and greedy. Alongside them, a Month 1 calibration programme: a timed protocol, a cold diagnostic with the topic hidden until you've scored yourself, and a re-test that says whether the month moved the number.
Guided path · Learn / Interview Open collection 07Problem Editorials
Curated problems, each written up the way an editorial should be — why the obvious idea fails, the observation that forces the data structure, then commented Java. Sorted into categories, every one with a live simulator, a dry-run table and a one-month recall check. Seven categories so far — stacks, sliding windows, hashing, heaps, binary search, bit manipulation and array invariants.
Open field guide 08Binary Search — Derived, Not Memorized
A derivation-first guide to binary search — starting from the single unifying idea ("find the first TRUE"), then working through classic boundaries, rotated and peak search, binary search on the answer, count-based search over a value domain, binary search as a helper, and partition search. Closes with a failure-modes catalogue and a 5-minute revision sheet.
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
07 collections · 25 chaptersFoundations
The everyday Python toolkit the rest of these notes assume — the subset you actually reach for when writing retrieval and agent code.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview Open collection 05Production Agent Operations
The controls that let an agent act without turning one bad decision into a production incident — idempotent writes, risk-tiered permissions, human approval gates, persistent state for recovery, and layered defenses against injection and PII leakage.
Guided path · Learn / Interview Open collection 06Multi-Agent Systems
How specialist agents cooperate without becoming a distributed monolith — choosing a topology, scoping tools and state, formalizing handoffs, and using a supervisor to route ambiguous work and decide when the system is finished.
Guided path · Learn / Interview Open collection 07DSPy
Programming language models instead of prompting them — signatures, modules and optimisers, and what it looks like when the prompt becomes a compiled artefact.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview 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.
Guided path · Learn / Interview Open collectionByteByteGo
04 courses · 49 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, and a five-step framework for keeping a deliberately open-ended prompt on the rails. Then seven worked case studies: an offline news feed, 1:1 chat, stock trading, a reusable pagination library, hotel booking, Google Drive and YouTube — closing on a building-blocks reference and an interview cheat sheet.
Open courseFinance
03 courses · 01 lab · 26 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 03Fundamental Analysis — Varsity
The other half of the argument: valuing the business rather than the chart. Where a company's real story is written down, then the three statements read in order — the P&L from revenue down to EPS, both sides of the balance sheet, and the cash flow that cuts through profit to what actually paid the bills. The ratios follow (profitability, leverage, efficiency, valuation), then a moat, a 10-point due-diligence checklist, and a DCF built from the time value of money up to an intrinsic value you still discount for margin of safety.
Open course 04Finance Lab — interactive
The tools from the courses, in one place — a live valuation & ratio calculator seeded with real figures, a cross-market stock comparison, candlestick charts, and a pattern-spotting exercise where the outcome is revealed only after you commit. Plus a case gallery of strategies that paid and strategies that stung. Learn by doing, not just reading.
Open lab