Vishal Verma VV
Learningin public
System Design Distributed Systems AI System Design RAG Agents LangChain LangGraph MCP Evaluation Certification Low-Level Design System Design Distributed Systems AI System Design RAG Agents LangChain LangGraph MCP Evaluation Certification Low-Level Design
01
System Design
50 topic notes · 217 problems · 5 revision sheets
The active track. The takeUforward roadmap broken into atomic notes, then every Codemia problem regrouped by shared architecture so there are 29 skeletons to learn instead of 217 problems to memorise. 50 of the 67 roadmap topics have notes.
Basics Load Balancing DataStores Consistency vs Availability Message Queues DevOps Caching Microservices API Gateways Authentication Trade-offs Practice Problems Low-Level Design
01
Pattern Map
All 217 Codemia problems grouped by architecture into 29 skeletons , one goal problem per family, plus a 14-problem shortlist that touches every skeleton. Progress saves in the browser.
Interactive Checkboxes Dark / light
Open ↗
02
Core Roadmap Q&A
The whole roadmap as 67 questions across 12 sections, with a hide-answers self-test mode and a print stylesheet.
67 questions Self-test Printable
Open ↗
03
HLD Revision Sheet
Fifty high-level design questions — scaling, storage, consistency, queues — for a fast pass before an interview.
50 questions High-level design
Open ↗
04
LLD Revision Sheet
Fifty low-level design questions — class modelling, SOLID, design patterns, concurrency — the object-design half of the loop.
50 questions OOD Design patterns
Open ↗
05
Uber — worked end to end
A full design in two printable pages: Redis geohash dispatch, the distributed lock, late Kafka offset commits, durable execution and geo-sharding.
Geo dispatch Kafka 2 pages, A4
Open ↗
06
The 50 topic notes
One note per concept — consistent hashing, LSM-trees, CAP and PACELC, the transactional outbox, cache write policies, rate limiting — each with a worked example.
Atomic notes Cross-linked
Open ↗
07
Codemia Catalog
The full problem catalog — 127 system design , 70 OOD/LLD and 18 agentic AI — with the core twelve cross-marked.
127 SD 70 LLD 18 Agentic
Open ↗
08
Explained like you're ten
Every basic concept retold as one running pizza-shop story — the version I reach for when a definition hasn't stuck.
Intuition first No jargon
Open ↗
02
AI System Design
20 parts · 167 chapters · 54 printed pages
The distributed-systems half of AI: retrieval architecture, agent topologies, inference cost, evaluation and safety. A twenty-part guide, of which six parts are fully written up as atomic notes so far.
Foundations Model Landscape Training & Adaptation Inference Optimization Prompting & Context Retrieval (RAG) Agentic Systems Memory & State Frameworks & Tools Document Processing Infrastructure & MLOps Security & Access Reliability & Safety Evaluation & Observability AI Design Patterns Case Studies Tool Use & Computer Agents Voice & Audio Multimodal Generation Interview Prep
01
The complete guide
Twenty parts and 167 chapters in a single browsable file — from foundations through retrieval, agents, MLOps, safety and evaluation.
20 parts Single file Searchable
Open ↗
02
Printable edition
The same guide as a 54-page PDF for reading away from a screen.
PDF 54 pages
Open ↗
03
Retrieval systems
RAG fundamentals, chunking strategies, embedding models, vector databases, hybrid search, reranking, agentic RAG and GraphRAG.
9 notes Hybrid search GraphRAG
Open ↗
04
Prompting & context engineering
Fundamentals, few-shot and in-context learning, chain-of-thought, tree-of-thought, structured generation, DSPy optimisation and prompt-injection defense.
8 notes DSPy Injection defense
Open ↗
05
Training & adaptation
Pretraining basics, fine-tuning strategies, LoRA/QLoRA/PEFT, quantization, RLHF and DPO, RLVR and reasoning models, distillation, synthetic data.
8 notes LoRA RLHF / DPO
Open ↗
06
Frameworks & tools
LangChain, LangGraph, LlamaIndex, DSPy, Semantic Kernel, AutoGen and CrewAI, LangSmith observability — plus a selection guide for choosing between them.
9 notes Selection guide
Open ↗
07
Case studies
Enterprise RAG, customer-support automation, a coding assistant, an autonomous coding agent, document intelligence, content moderation, real-time search, multi-tenant SaaS, financial analysis and a conversational agent.
10 designs End to end
Open ↗
08
Interview prep
A question bank spanning RAG, agents, optimisation and evaluation; answer frameworks (SPIDER , ETA, STAR-L); nine whiteboard exercises; and the common pitfalls to avoid.
Question bank Frameworks Whiteboard drills
Open ↗
03
Agent Engineering
13 notebooks · 12 written up · 33 notes
The hands-on half — code I actually ran, then turned into notes. LangChain v1 and LangGraph end to end, plus the infrastructure around an agent: MCP servers, a model gateway, retrieval without a vector database, and evaluation.
01
LangChain v1 — master file
All seven notebooks condensed into one: create_agent, tools and the three-step execution loop, message types, structured output, middleware (summarization, human-in-the-loop) and a five-layer guardrail stack.
Agents Tools Middleware Guardrails
Open ↗
02
LangChain self-test
Sixty questions with collapsed answers and code drills — the check that the notes actually stuck.
60 questions Code drills
Open ↗
03
LangGraph — five modules
StateGraph and the add_messages reducer, the ReAct back-edge, checkpointing with thread_id, interrupt() for human approval, multimodal RAG with CLIP, and sequential vs supervisor vs hierarchical multi-agent.
StateGraph Checkpointers Multi-agent
Open ↗
04
MCP servers
Server, client and app roles; stdio versus HTTP transports; building one with FastMCP — how a model gets tools it didn't ship with.
FastMCP Transports
Open ↗
05
LLM gateway
One API across providers, with routing, fallbacks, caching and cost tracking — an API gateway, but for models.
LiteLLM Fallbacks Cost tracking
Open ↗
06
Vectorless RAG
Retrieval with no chunking, no embeddings and no vector database — build a tree index from the document's own structure and let the model search it.
PageIndex Tree search
Open ↗
07
Evaluation with LangSmith
Datasets and LLM-as-judge scoring — how to choose a model on evidence instead of vibes, and how to catch a regression before users do.
Datasets LLM-as-judge Tracing
Open ↗
08
The 11-hour course map
A timestamp map of the source video to the note that covers each section — including the gaps I haven't closed yet.
Timestamped Gap tracking
Open ↗
04
Certification
CCAR-P · 63 items · 7 domains
Preparing for Claude Certified Architect — Professional : 63 items, 120 minutes, 720 of 1000 to pass. I built a practice-exam engine that samples the real blueprint weights and teaches the topic on the spot when I get one wrong. Six of the seven domains have notes; Domain 6 is the open gap.
1 · Solution Design & Architecture — 17% 2 · Models, Prompting & Context — 13% 3 · Integration — 19% 4 · Evaluation, Testing & Optimization — 16% 5 · Governance, Safety & Risk — 14% 6 · Stakeholder Comms & Lifecycle — 14% 7 · Developer Productivity — 7%
01
Daily practice exam
A generated paper — multiple-choice and multiple-response — scored on the real scale, with an explanation for the right answer and for why each distractor is wrong.
Auto-scored Teaches on miss Scaled 100–1000
Take it ↗
02
Blueprint & gap analysis
The seven domains with their exam weights, mapped against what the vault actually covers — so revision goes where the gap is, not where it's comfortable.
7 domains Weighted Honest gaps
Open ↗
03
AI Fluency framework
Anthropic's course hub — Delegation, Description, Discernment and Diligence, with per-lesson notes.
4 Ds Per-lesson notes
Open ↗
04
AI Fluency glossary
The vocabulary in one place — the four Ds and their sub-skills, interaction modes, and the technical and prompting terms underneath them.
Terminology Quick lookup
Open ↗
05
Claude Code course
How an agentic coding tool actually works — the agent loop, context compaction, permission modes — and the Explore → Plan → Code → Commit workflow.
Agent loop Plan mode 3 lessons
Open ↗
05
Reference Library
136 notes · one searchable file
The machinery underneath: every study note rendered into one searchable page, the catalog that indexes them, and the raw markdown export. Personal planning and progress tracking stay in the vault.