Changelog
November 2026
November 13, 2026 — BGP, Explained From Zero
- BGP — Border Gateway Protocol rewritten for beginners (1,350 → 20,000 words): a toy internet you watch route announcements spread through, how routers peer, best-path selection with worked examples, why money shapes routes, real hijacks and leaks with RPKI as the defence, anycast and data-centre BGP, the Facebook 2021 and Cloudflare 2026 case studies, and a runnable simulation. Eight factual fixes to the old page.
November 12, 2026 — Go Interview Questions
- Go Interview Questions — 60 questions from junior to staff (slices and aliasing, interfaces and typed nil, generics, the Go 1.22 loop-variable change, channels,
select,context,sync, the memory model, escape analysis, GC, pprof, fuzzing,synctest), 9 output puzzles and 7 write-it-from-scratch builds (worker pool, token bucket, pub-sub, retry, LRU, singleflight, pipeline) — every snippet run on Go 1.26.
November 12, 2026 — DSA Course: String Algorithms & Math for Algorithms
+18 new pages, 3 animations, 4 visualizers. DSA: Zero to Mastery now has 9 modules live.
- Module 7 · String Algorithms complete — Suffix Arrays & LCP, Suffix Automaton, Suffix Trees with Ukkonen, Palindromes & Manacher (with the eertree), Minimal Rotation & Lyndon Words, How Regex Engines Work (a tested Thompson-NFA engine in four languages, ReDoS incidents), and a mini grep / full-text search capstone.
- Module 8 · Math for Algorithms — Number Theory I, Modular Arithmetic, Number Theory II (Miller–Rabin, Pollard's rho, discrete logs), Combinatorics, Probability & Expected Value, Linear Algebra, FFT & NTT, Computational Geometry, Game Theory, and a crypto & numerics toolkit capstone. The overview includes an overflow and precision primer for Python, Java, C++ and JavaScript.
- Animations for LIS patience sorting, knapsack table filling and the edit-distance table; visualizers for suffix-array doubling, suffix-automaton construction, Manacher and the monotone-chain convex hull.
- Correction: the Randomized Algorithms lesson gave the wrong range for the twelve deterministic Miller–Rabin bases (it is , not ).
November 12, 2026 — DSA Course: Paradigms & the Complete Dynamic Programming Series
+24 new pages, 4 expanded, 22 animations, 4 visualizers. DSA: Zero to Mastery now has 7 modules live.
- Module 5 · Algorithmic Paradigms — Recursion & Backtracking, Greedy Algorithms and Bit Manipulation rewritten into full lessons (all original content kept; corrections on the Sudoku solver's return value and on longest path), plus new Divide & Conquer and Randomized Algorithms lessons and a Sudoku & N-Queens solver-engine capstone.
- Module 6 · Dynamic Programming — the overview becomes the module map, and 17 new lessons complete the series: DP Foundations, 1-D DP, Knapsack, Sequence DP, Interval DP, Partition DP, Tree DP & Rerooting, DAG DP, Bitmask DP, SOS DP, Digit DP, Broken-Profile DP, Counting DP, Probability DP, Game DP, Matrix Exponentiation, DP Optimizations and DP Debugging, with a diff tool & spell-checker capstone.
- Module 7 · Strings joins the course map with its first five lessons (overview, String Hashing, KMP, Z-Algorithm, Aho–Corasick) and the earlier String DP and Grid DP lessons now sit in Module 6.
- 22 new animations across Modules 1–4 and Strings: two pointers, sliding window, prefix sums, binary-search boundaries, Lomuto partition, merge sort, heap sift, AVL rotations, segment-tree lazy propagation, Fenwick updates, tries, BFS wavefront, DFS stack, Dijkstra, Bellman-Ford, union-find path compression, Kruskal, Kahn, the KMP failure function, the Z-algorithm, monotonic stack and Floyd's cycle detection.
- New step-through visualizers: knapsack table, LIS patience sorting, edit-distance table, backtracking subsets tree.
- Every lesson's code runs in Python, Java, C++ and TypeScript, and every worked number was recomputed by script.
November 12, 2026 — Clearer Navigation
- Menus regrouped into Courses · Foundations · Infra & Ops · Engineering · Data & AI · Real World · Interview Prep · Explore. All the data and AI sections now sit together, Production Blueprints joins the real-world sections, and Interview Prep lists the LLD course. Every page keeps its URL.
- Consensus moves to the Distributed Systems Course. The System Design course's coordination module now covers clocks, leader election, locking, transactions and exactly-once, and points to the Distributed Systems course for Raft and Paxos.
November 10, 2026 — Low-Level Design Course Complete
+59 new pages, 14 rewritten. Archon reaches 1,400+ pages.
The Low-Level Design Course is complete: 7 modules, 91 lessons, about 54 hours, all code runnable in Java, Python and TypeScript.
- Design Principles beyond SOLID — DRY/KISS/YAGNI, composition over inheritance, cohesion & coupling, designing for testability, immutability & value objects, error handling, class-level API design.
- Design Patterns, one page each — all 23 GoF patterns plus Object Pool, Specification, Null Object and a Pattern Selection Guide for the look-alikes.
- Concurrency in LLD — thread-safe class design, concurrency patterns inside object designs, and preventing double booking (examples run against a real PostgreSQL).
- All 11 classic case studies rewritten to the full structure — requirements, class and state diagrams, three-language code, concurrency, "the interviewer adds X", tests — with bugs in the old code fixed (the ATM PIN counter, vending-machine float money, elevator hall-button direction, hotel overbooking, chess castling).
- 16 new case studies — LRU/LFU Cache, Logger, Rate Limiter, KV Store, Pub-Sub, Task Scheduler, Notification Service, Splitwise, Ride Sharing, Food Delivery, Car Rental, Online Auction, Shopping Cart, Stack Overflow, Meeting Room Booking and Cricbuzz.
- Practice ladders — easy, medium and hard problem ladders with hints and solution outlines.
November 10, 2026 — Low-Level Design Course (Wave 1)
+9 new pages.
- Low-Level Design Course — a fifth guided course with its own sidebar and progress tracking: OOP & modelling, design principles, design patterns, the LLD interview method, concurrency in LLD, and case studies. It joins the homepage core track and the starting-point picker (new goal: an LLD / machine-coding interview).
- Module 1, modelling — UML for Interviews and From Nouns to Classes.
- Module 4, the interview method — The LLD Interview Framework, How LLD Interviews Are Scored, Machine Coding Rounds, Common LLD Mistakes and a full Mock Interview: Parking Lot — every code sample compiled and run in Java, Python and TypeScript.
- Coming in the next waves: more design principles, concurrency in LLD, one page per design pattern, deeper classic case studies and 16 new ones.
November 9, 2026 — New Homepage Flow & 11 War Room Post-Mortems from 2026
+11 new pages.
- New-visitor flow — the homepage and Begin Your Journey now lead with the core track (CS Core → DSA → System Design → Distributed Systems, with progress), a three-question starting-point picker, and continue where you left off for returning readers.
- War Room: the incidents of 2026 — Cloudflare BYOIP withdrawal, Cisco SD-WAN CVE-2026-20127, Vertex AI "Double Agents", Canvas / Instructure breach, DENIC .de DNSSEC outage, TanStack supply-chain attack, Nx Console & GitHub repositories, Google Cloud europe-west4 thermal event, keyv "ChainDrop" worm, tampered Claude Code extension on Cursor's marketplace and the Binance hot-wallet hack — each with a sourced timeline, root cause, detection and the controls that would have prevented it.
November 9, 2026 — Cheat Sheets Reviewed, Interview Prep & Math Rewritten, Course Sidebars Stay Put
- Courses keep their sidebar — CS Core, Distributed Systems and DSA lessons that live in other sections now keep the course sidebar while you're inside the course, instead of switching to that section's sidebar.
- All 28 Cheat Sheets reviewed — wrong and deprecated commands fixed, current versions (Compose v2, Kubernetes removed APIs, Terraform import/moved blocks, Redis 8, pandas 3, Spring Boot 4, Helm 4…), missing everyday commands and gotchas added; LLM APIs refreshed to current models and SDKs. Sheets now read as one full-width column, and the index lists every sheet.
- Interview prep rewritten — JavaScript (58 questions + output puzzles + write-it-from-scratch), React (42, including React 19 and Server Components) and Node.js (45, event-loop phases, streams, workers, security): every answer with runnable code, the common wrong answer and the follow-up.
- Math for engineers — Probability, Statistics & A/B Testing and System Design Math rebuilt from intuition to worked examples (birthday collisions, availability and quorum math, sample size, peeking, CUPED, full back-of-the-envelope estimates), every snippet executed.
November 9, 2026 — DSA: Zero to Mastery (Wave 3): Graphs
+14 new pages, the Graphs overview expanded, 10 new step-through visualizers. Archon reaches 1,350+ pages.
- Module 4 · Graphs — Graph Modeling & Implicit Graphs, BFS in Depth, DFS in Depth, Topological Sort & DAG DP, Shortest Paths (Dijkstra, Bellman-Ford, Floyd-Warshall, Johnson, A*), Union-Find in Depth, Minimum Spanning Trees, Connectivity: Bridges, Articulation Points & SCCs, Euler & Hamiltonian Paths, Bipartite Matching & the Hungarian Algorithm, Network Flow, 2-SAT & Graph Coloring, Graph Algorithms in the Real World and a road-network capstone running Dijkstra and A*.
- Expanded — Graphs is now the Module 4 landing page, grown from about 1,700 to 15,000 words with every original section kept. Corrected: a quadratic
shift()-based BFS, the stack-space claim for iterative DFS, Dijkstra's behaviour with negative edges, Bellman-Ford's negative-cycle detection scope, Floyd-Warshall's handling of parallel edges, and two code blocks with missing imports. - New visualizers — BFS, DFS edge classification, Kahn's topological sort, Dijkstra, Bellman-Ford, union-find path compression, Kruskal, Tarjan's SCC, Kuhn's matching and Edmonds-Karp augmenting paths.
November 9, 2026 — DSA: Zero to Mastery (Wave 2): Searching & Sorting, Trees
+24 new pages, 3 pages expanded, 13 new step-through visualizers. Archon reaches 1,340+ pages.
- Module 2 · Searching & Sorting — Elementary Sorts & Stability, Merge Sort & Inversion Counting, Quick Sort & Introsort, Heap Sort, Non-Comparison Sorts & the Lower Bound, Sorting in the Real World (Timsort, pdqsort, external merge sort), Binary Search Mastery, Other Searches, Quickselect & Order Statistics and a sorting library capstone.
- Module 3 · Trees — Binary Trees & Traversals, Tree Problem Patterns, Binary Search Trees, AVL & Red-Black Trees, Treaps, Splay Trees & Skip Lists, Tries, Segment Trees, Fenwick Trees, Sparse Tables & Mo's Algorithm, LCA & Binary Lifting, Heavy-Light & Centroid Decomposition, Spatial Trees and a range-query engine capstone.
- Expanded — Sorting & Searching, Trees and Heaps & Priority Queues, each from about 2,000 to 9,000+ words with every original section kept. Corrected: an AVL rotation diagram that dropped a node, a binary-search exercise trace, a heap exercise answer, and an outdated note on JavaScript sort stability.
- New visualizers — insertion sort, merge sort, quicksort partition, heap sort, counting sort, lower_bound, AVL insertion, heap operations, trie insertion, segment tree query, Fenwick update, iterative inorder traversal and binary-lifting LCA.
November 9, 2026 — DSA: Zero to Mastery (Wave 1): Foundations & Linear Data Structures, Step-Through Visualizers
+22 new pages, 3 pages expanded. Archon reaches 1,310+ pages.
- DSA: Zero to Mastery — a fourth guided course, for data structures and algorithms. Every lesson follows one format: pattern triggers, a brute force → better → optimal ladder, a hand-computed trace table, a correctness proof, complexity, real-world uses, pitfalls, variations, a practice ladder of 15 problems with hints and solutions, interview follow-ups, and code in Python, Java, C++ and TypeScript that is compiled and run before it ships. This release opens the first two modules; the rest follow module by module.
- Module 0 · Foundations — How to Use This Course, Complexity Analysis (asymptotics, amortized analysis three ways, recurrences and the Master theorem), Recursion & Induction, How Data Structures Live in Memory, Your Language's Data Structures, How to Solve Any Problem, Testing & Debugging Algorithms and a benchmarking capstone.
- Module 1 · Linear Data Structures — Two Pointers, Sliding Window, Prefix Sums, Matrices & Grids, Strings in Depth, Stacks, Queues & Deques, Monotonic Stack & Deque, Intervals, Probabilistic Data Structures and an LRU cache capstone.
- Expanded — Arrays & Strings, Linked Lists and Hash Tables grew from about 2,000 to 10,000+ words each, with every original section kept. Corrected: the old linear-probing example could store a key twice after a delete, and the open-addressing probe-count formula was stated for the wrong hashing model.
- Step-through visualizers — a new interactive component plays an algorithm one step at a time (play/pause, step, speed, keyboard arrows, light/dark, works on phones). Traces are generated by running the real algorithm (
scripts/traces/). - Algorithms sidebar now follows the course, module by module with numbered lessons; the JavaScript, React, Node.js, regex, probability and statistics pages are grouped under Interview Language Prep & Math.
November 9, 2026 — Distributed Systems Course, Landmark Systems, Deeper DS Pages
+18 new pages. Archon reaches 1,290+ pages.
- Distributed Systems Course — a third guided course with its own sidebar: 9 modules, 45 lessons: foundations, communication, replication & partitioning, time & causality, consensus, coordination & transactions, failure & recovery, Byzantine faults & trust, and landmark systems. The System Design sidebar now links to it instead of listing every part.
- New fundamentals — System Models, Failure Models & Correctness, Quorums & Leaderless Replication, Replicated State Machines, Causality & Version Vectors, Leases & Fencing, Timeouts, Retries, Backoff & Hedging, Serialization & Wire Formats, Cryptography Primer & PKI.
- Landmark Systems — the papers that defined the field, read as case studies: GFS & HDFS, MapReduce & Spark, Bigtable & HBase, Amazon Dynamo, ZooKeeper, Spanner & TrueTime, Calvin & FaunaDB, Distributed Ledgers.
- 12 Distributed Systems pages rewritten in depth — FLP, Paxos, Leader Election, Exactly-Once, Replication, CAP, Circuit Breaker, Distributed Locking, Bloom Filters, Queueing Theory, Rate Limiting and Consistent Hashing, each now 5,000+ words with proofs, worked examples and failure timelines. Factual errors fixed along the way (e.g. DynamoDB is leader-per-partition, not leaderless like the Dynamo paper).
November 8, 2026 — CS Core Fundamentals Course, DBMS Theory, Networks & Concurrency Problems
+26 new pages. Archon reaches 1,270+ pages.
- CS Core Fundamentals — a second guided course: OOP, Operating Systems, Concurrency & Parallelism, Computer Networks and DBMS — 72 ordered lessons. OS internals, concurrency and low-level networking moved here from the System Design course, which now focuses on design (11 modules, 76 lessons) and points to this course as its foundation. Lessons in both courses follow whichever course you came from.
- DBMS as a subject — The Relational Model & Relational Algebra, SQL Fundamentals, Advanced SQL, ER Modeling, Functional Dependencies & Normalization Theory, Concurrency Control.
- Every classic concurrency problem, solved — Classic Synchronization Problems (critical section, Peterson/Dekker/Bakery, producer–consumer, readers–writers, dining philosophers with 5 solutions, sleeping barber, smokers, Santa Claus) and Concurrency Interview Problems with Java, Python and Go solutions.
- Networks, layer by layer — Data Link Layer, Network Layer, Application Layer Protocols.
- Foundations — How Computers Work, OS Algorithms (Banker's, page replacement, disk scheduling, file allocation), OOP Concepts & UML.
- Requirements: Functional vs Non-Functional — the new Module 1 lesson on where every design starts: functional vs non-functional requirements, SLIs/SLOs/SLAs, turning "fast" and "always up" into numbers, and how requirements drive architecture.
- Databases at scale — OLTP vs OLAP vs HTAP, OLTP Database Design, Time-Series & IoT Storage Engines (TSM trees, Gorilla compression, Prometheus TSDB); ClickHouse Internals and the four schema-design pages expanded several-fold, with bugs in the original SQL fixed.
- Sidebars follow the learning paths — Distributed Systems, Caching, Load Balancing, Message Queues and Consensus now list their pages in the order their overview pages teach them (Distributed Systems grouped into its 7 parts).
- CS course navigation — OS, concurrency and networking pages now show the CS Core Fundamentals sidebar, laid out as the course itself (Module 1 → 5, numbered lessons, then "More topics"); the System Design sidebar focuses on design. The Foundations menu separates Guided Courses from Browse All Topics.
- Lighter, faster site — code is now coloured in the browser as you scroll, cutting each deploy from ~350 MB to ~100 MB and making long pages load much faster; the "On this page" outline sits at the right edge on Explore pages.
- Contributing Guide — how to write pages, Mermaid diagrams, Manim animations and work on the Zola site, plus
npm run check:links/check:mermaid.
November 8, 2026 — System Design Course, OS Internals Rebuilt, 10 New Animations
+12 new pages. Archon reaches 1,270+ pages.
- System Design Course — a guided route through the whole System Design section: 12 modules, 96 ordered lessons, every page placed in a progressive order, a capstone design at the end of each module and three final capstones. Each lesson shows where you are ("Module 2 · Lesson 5 of 8"), a module progress bar and a Mark lesson done & continue button; progress uses your sidebar ticks.
- 4 new lessons — How a Database Works, Transactions, ACID & Concurrent Updates, RPC Fundamentals, Raft in Plain English.
- 10 new animations — 2PC & sagas, CDN request flow, vector clocks, backpressure, fencing tokens, the cache-invalidation race, majority commit under a partition, exactly-once dedupe, DNS resolution and B+tree index lookups.
- System Design sidebar in learning order — sections follow the course (fundamentals → databases → caching → networking → APIs → messaging → distributed systems → consensus …); inside Databases, design topics come first, then engine internals, then specific databases.
- OS Internals rebuilt — 7 new pages: Kernel Synchronization (spinlocks, futexes, memory barriers), Inter-Process Communication, Page Cache & fsync, The Linux Networking Stack, Interrupts, DMA & Drivers, Process Isolation & Security and The Boot Process. All 10 existing OS pages expanded from ~1,500 to 8,000–11,000 words each — including time slices, CFS and EEVDF with worked numbers in CPU Scheduling — with factual errors corrected. They form the course's bonus module (96 lessons in total).
- Smoother navigation — pages pre-load when you hover a link, switch with a crossfade instead of a full flash, and the sidebar keeps its scroll position.
- 44 broken Mermaid diagrams fixed across 38 pages — every one of the site's 3,400+ diagrams now parses.
November 8, 2026 — Archon Now Runs on Zola
The whole site moved from VitePress to Zola, a Rust static site generator. Full builds dropped from ~15 minutes (with a 24 GB heap) to seconds.
- Same look, same features — nav, sidebar, outline, search, AI chat, knowledge graph, compare, tags, tickboxes and progress, bookmarks, notes, streaks, code tools, Mermaid diagrams, math and the diagram viewer were all ported. Your saved ticks, bookmarks and settings carry over.
- Roomier layout — wider sidebar and outline on large screens, so topic names and headings fit on one line and the article gets more space.
- Better math and links — math renders correctly where the old site broke formulas inside table cells; every heading anchor matches the old site, so existing deep links still work.
- New domain — archon.ayushjadaun.com.
- Cleanups — learning-path progress bars now count your sidebar ticks (one progress system instead of two); copied code from 100 pages no longer contains hidden characters inside
{{ }}; the knowledge graph colours and filters every section; two broken Kafka diagrams fixed. - VitePress fully removed — nav and sidebar now live in a plain
zola/nav.json; Vue, VitePress and 6 other build packages are gone (the install shrank to 21 packages), and CI runs on current Node 24 GitHub Actions. - +9 new pages, 28 dead links fixed — Data Platform Design, Engineering Practices overview, Monitoring & Alerting: Symptom → Playbook, Kubernetes Resource Management, Frontend Performance, Node.js Performance, V8 & Node.js Internals, Database Scaling, Design System Governance. Archon reaches 1,270+ pages.
November 7, 2026 — Progress Tracking, HTTP QUERY, HATEOAS & 7 More Animations
+2 new pages. Archon reaches 1,270+ pages.
- Progress counters — every sidebar section shows a done/total count from your tickboxes, turning green when complete
- Learning-path progress bars — each learning path shows % complete across the topics it links to
- The HTTP QUERY Method (907 lines) — RFC 10008: the safe, idempotent, cacheable method with a body. Accept-Query, body-keyed caching, Location vs Content-Location, Fastify/fetch code, fallbacks, real support status
- HATEOAS & Hypermedia APIs (1,285 lines) — Fielding's uniform interface, HAL vs JSON:API vs Siren vs Hydra, state-driven links in TypeScript, link-following clients, and why almost nobody ships it
- 7 new animations — Raft log replication, Paxos prepare/accept, Kafka partitions & consumer groups, sharding & scatter-gather, cache-aside, round robin vs least connections, B-tree vs LSM write paths
November 7, 2026 — Animations, Live Diagrams & Nav Refresh
- Animated explainers — 8 Manim-rendered animations embedded in System Design pages: CAP partition, circuit breaker, consistent hashing, horizontal scaling, leader election, replication lag, thundering herd, token bucket
- Live Mermaid diagrams — new dark-canvas diagram theme with brand-tinted nodes, plus flowing data dots along flowchart edges (respects reduced-motion)
- Typography & nav — Source Serif 4 / Inter / JetBrains Mono fonts, responsive search button that collapses to an icon on narrower screens, share button moved into the doc header
November 7, 2026 — Topic Progress Tickboxes
- Mark topics done — every sidebar topic now has a tickbox. Ticked topics get a green check and dimmed title. Progress is saved locally in your browser (no account, nothing sent to a server) and syncs across open tabs.
April 2026
April 5, 2026 — Essential Engineering Pages: 8 More
+8 new pages. Archon reaches 1,195+ pages.
- Docker Compose Deep Dive (1,334 lines) — Multi-service patterns, healthchecks, networking, dev vs prod, Compose Watch
- Nginx Complete Guide (1,208 lines) — Reverse proxy, load balancing, SSL, rate limiting, caching, security headers, tuning
- PostgreSQL Performance Tuning (1,058 lines) — EXPLAIN ANALYZE, index strategies, VACUUM, PgBouncer, memory tuning
- TypeScript Advanced Patterns (1,838 lines) — Generics, conditional types, mapped types, template literals, branded types, type-level programming
- AWS Services Cheat Sheet (788 lines) — 60+ services by category with pricing, gotchas, decision matrices
- Incident Response Playbook (1,082 lines) — Full lifecycle, SEV levels, communication templates, postmortem framework
- Database Migration Strategies (964 lines) — Zero-downtime patterns, expand/contract, gh-ost, dual-write, tool comparison
- API Rate Limiting Deep Dive (1,111 lines) — 5 algorithms with Redis Lua scripts, distributed patterns, adaptive limiting
April 4, 2026 — Dev Tools & Infrastructure: 8 New Pages
+8 new pages. Archon reaches 1,187+ pages.
Frontend Tools
- Bun Runtime (1,331 lines) — All-in-one JS runtime, Bun vs Node.js vs Deno, Bun.serve/SQLite APIs, bundler, test runner
- htmx (1,244 lines) — Hypermedia-driven development, AJAX patterns, server-side integration, htmx vs React/Vue
- Tauri (1,335 lines) — Rust-based Electron alternative, commands, plugins, security model, Tauri 2.0 mobile
- WebAssembly Components (1,090 lines) — WASI 0.2, WIT interfaces, component model, Spin/wasmCloud/SpinKube
Architecture & Data
- Serverless Databases (955 lines) — Neon, PlanetScale, Turso, D1, Supabase comparison
- Effect-TS (1,204 lines) — Type-safe functional effects, typed errors, dependency injection, concurrency
Infrastructure
- eBPF in Production (1,408 lines) — Cilium, Falco, Tetragon, XDP DDoS mitigation, continuous profiling
- Platform Engineering Maturity (980 lines) — Maturity model, Backstage, golden paths, DX metrics
March 2026
April 4, 2026 — AI/LLM Era: 8 New Pages
+8 new AI/LLM pages. Archon reaches 1,180+ pages.
- MCP Protocol Deep Dive (2,319 lines) — Architecture, tools/resources/prompts, building servers + clients in TS/Python, advanced patterns, production deployment
- Agentic RAG Patterns (1,534 lines) — Self-correcting, multi-step, routing, agent-based RAG with LangGraph + LlamaIndex implementations
- Local LLMs Guide (1,309 lines) — Ollama, llama.cpp, vLLM, GGUF quantization, hardware guide, model selection matrix
- Fine-Tuning LLMs (1,752 lines) — LoRA, QLoRA, PEFT, data prep, RLHF/DPO, evaluation, Hugging Face + cloud platforms
- Structured Output from LLMs (1,460 lines) — JSON mode, Instructor, Zod, function calling, validation, streaming
- AI Safety & Red Teaming (1,430 lines) — Prompt injection, jailbreaks, guardrails, OWASP LLM Top 10, PII redaction
- A2A Protocol (1,317 lines) — Google's agent-to-agent interop standard, Agent Cards, task lifecycle, vs MCP comparison
- AI Coding Assistants (1,014 lines) — Copilot vs Cursor vs Claude Code vs Windsurf comparison, effective usage patterns
April 4, 2026 — Cloudflare, Email Security, OpenTelemetry, Regex, Redis Pub/Sub
+5 new pages. Archon reaches 1,170+ pages.
- Cloudflare Complete Guide (846 lines) — DNS, CDN, WAF, DDoS, SSL/TLS, Page Rules, Zero Trust, Workers ecosystem, migration guide
- Email Security & Deliverability (1,227 lines) — SPF, DKIM, DMARC deep dive, BIMI, MTA-STS, deliverability scoring, transactional email comparison
- OpenTelemetry (752 lines) — Traces, metrics, logs, Collector pipelines, auto-instrumentation in 4 languages, backend integration
- Regex Mastery (885 lines) — Complete tutorial from basics to lookaround, regex in 6 languages, 12 worked examples, performance/ReDoS
- Redis Pub/Sub Patterns (711 lines) — Production patterns, scaling, Pub/Sub vs Streams vs Kafka decision flowchart, reliability patterns
April 4, 2026 — OOP Fundamentals, Cron Jobs & Axios War Room
+4 new pages. Archon reaches 1,165+ pages.
New Pages
- OOP Fundamentals (3,098 lines) — Complete OOP reference: 4 pillars, SOLID with before/after code, composition vs inheritance, 12 design patterns, mixins/metaclasses/generics, OOP in 5 languages (Java, Python, TypeScript, Go, Rust), anti-patterns, OOP vs FP, domain modeling. 74 code blocks, 6 Mermaid diagrams, 15 interview Qs, 10 quiz Qs.
- Cron Jobs (infrastructure) — Cron syntax, crontab, systemd timers, K8s CronJobs, cloud schedulers (EventBridge, Cloud Scheduler), monitoring with dead man's switch
- Cron Patterns (devops) — Distributed cron, leader election, idempotency, overlap prevention, failure handling, migration to Temporal/Airflow
- Axios Supply Chain Attack (war room) — March 2026 North Korean state-linked attack on 100M+ weekly download npm package. Full timeline, attack chain, IOCs, decision scenarios.
Enhancements
- Model Optimization — Added Google TurboQuant (ICLR 2026) KV cache compression section
- Papers Reading List — New "Efficiency and Optimization" section with TurboQuant, GPTQ, AWQ papers
March 27, 2026 — Mobile Engineering Expansion + Site-Wide Interactive Enhancements
+14 new mobile pages. Archon reaches 1,160+ pages.
Mobile Engineering (14 new pages)
- CI/CD (Fastlane, GitHub Actions), Security (OWASP Mobile Top 10, certificate pinning), Deep Linking (Universal Links, App Links), Analytics (Firebase, Mixpanel), Architecture (MVVM, MVI, Clean), Networking (REST, GraphQL, WebSocket), State Management (Zustand, Riverpod, Bloc), Accessibility (VoiceOver, TalkBack), Animations (Reanimated, Lottie), ASO, Databases (WatermelonDB, Room), Cross-Platform Comparison, Payments (IAP, RevenueCat), Deployment (CodePush, Shorebird)
Interactive Enhancements (batch 2-6)
- War Room (9 pages) — "What Would You Do?" scenarios, Key Lessons, Quiz
- Frontend (10 pages) — Key Takeaway, Misconceptions, In Production, Quiz, Exercise
- Comparisons (20 pages) — "Which Would You Choose?", Migration Stories, Quiz
- Testing (4 pages) — Key Takeaway, Misconceptions, Quiz, Exercise
March 27, 2026 — Interactive Enhancements & Learning Paths Overhaul
Massive quality pass across the entire site. Every section gets richer, more interactive, and more useful.
Worked Examples (108 total)
- Machine Learning — 61 worked examples across 20 pages: mini datasets, step-by-step calculations, decision tree traces, gradient descent walks
- Deep Learning — 47 worked examples across 20 pages: tensor shapes, forward/backward pass traces, attention score calculations
Quizzes & Exercises
- Algorithms (13 pages) — 65 exercises + 65 quiz questions with hidden solutions
- EDA (15 pages) — 45 exercises + 75 quiz questions covering pandas, matplotlib, feature engineering
- System Design (23 pages) — Real-world company examples + interview tips across fundamentals, patterns, and advanced sections
- Spring Boot (24 pages) — Common pitfalls + interview questions for core, data, security, cloud modules
- War Room (3 pages) — "What Would You Do?" interactive incident response scenarios
- Testing (4 pages) — Key takeaway boxes + quiz questions
Learning Paths (14 paths rewritten/created)
- Rewritten (10): Backend, DevOps, Frontend, System Design Interview, Security, Data Engineer, AI/ML, Platform, Full-Stack, ML & Deep Learning
- New (4): Cybersecurity Engineer, Mobile Engineer, Data Scientist, Spring Boot Engineer
- All paths now reference new ML, DL, System Design, and EDA pages
Mobile Engineering
- New: Mobile Testing page (unit, integration, E2E, device farms)
Archon reaches 1,150+ pages.
March 25, 2026 — System Design Mastery
+52 pages. System design section restructured from 90 to 140+ pages.
System Design Fundamentals (12 pages)
- How the Internet Works, Client-Server, Scaling Fundamentals, Zero to Million Users, System Design Characteristics, Estimation Practice, Building Blocks Overview, Proxies, Redundancy & Replication, SQL vs NoSQL Decision, How to Read Architecture, System Design Glossary
System Design Patterns (12 pages)
- Scalability, Availability, Consistency patterns, Data Partitioning, Communication, ID Generation, Blob Storage, Distributed Logging, Notification Patterns, Search Patterns, Event vs Request Driven, Microservices vs Monolith
Interview Mastery (10 pages)
- Framework, Tradeoffs, Mistakes, Templates, Practice Questions, Mock Interview Walkthrough
Advanced Architecture (12 pages)
- Database Per Service, CQRS Decision, Serverless, Edge, Multi-Region, Cost of Scale, Anti-Patterns, DDIA Summary, Real-World Architectures, Security in Design, Observability in Design, Design Scenarios
LLD Practice (6 pages)
- 30 practice problems (easy/medium/hard), Design Scenarios, Architecture Review Exercises, Decision Log Template
March 25, 2026 — Machine Learning & Deep Learning
+56 pages. Archon reaches 1,091 pages.
Machine Learning (30 pages)
- Foundations (5) — Math for ML (linear algebra, calculus, probability with code), ML workflow, Python ecosystem, data preparation
- Supervised Learning (8) — Linear regression (OLS, gradient descent from scratch), logistic regression (MLE derivation), decision trees (CART/Gini/entropy), random forests (bagging, OOB), gradient boosting (XGBoost/LightGBM/CatBoost internals), SVM (kernel trick, Lagrangian), KNN, naive bayes — all with from-scratch NumPy + scikit-learn + real datasets
- Unsupervised Learning (5) — Clustering (K-Means/DBSCAN/GMM), dimensionality reduction (PCA/t-SNE/UMAP from scratch), anomaly detection (Isolation Forest), association rules (Apriori), topic modeling (LDA/BERTopic)
- Evaluation & Selection (4) — All metrics with math, cross-validation (7 methods), hyperparameter tuning (Optuna), model selection (bias-variance proof)
- Advanced (5) — Feature engineering, ensemble methods (stacking from scratch), time series ML (ARIMA), recommendation systems (SVD/ALS from scratch on MovieLens), SHAP/LIME interpretability
- Reference (3) — 50-item checklist, algorithm selection flowchart, scikit-learn cheat sheet
Deep Learning (25 pages)
- Foundations (3) — Neural network basics (backprop derivation from scratch), PyTorch fundamentals, training techniques (BatchNorm, dropout, LR scheduling math)
- Architectures (6) — CNN (LeNet→ResNet→EfficientNet), RNN/LSTM (gate equations), Transformers (full attention math from "Attention is All You Need"), VAE (ELBO derivation), GANs (minimax, WGAN), Graph Neural Networks (message passing, PyG)
- NLP (4) — Tokenization (BPE from scratch), language models (scaling laws), BERT family (fine-tuning CoLA+NER), text generation (top-k/top-p/temperature math, RLHF)
- Computer Vision (3) — Image classification (ViT, transfer learning), object detection (YOLO, DETR), segmentation (U-Net from scratch, SAM)
- Advanced (5) — Transfer learning (few-shot, zero-shot CLIP), model optimization (quantization INT8, pruning, distillation), diffusion models (DDPM, Stable Diffusion), reinforcement learning (DQN, PPO, CartPole), multimodal models (CLIP contrastive learning)
- Reference (3) — DL checklist, architecture selection guide, 30 must-read papers
- Learning Path — 16-week ML + DL study plan
Every page: full KaTeX math derivations + from-scratch NumPy/PyTorch code + library code + real dataset end-to-end example.
March 25, 2026 — Spring Boot, Data Pipeline & MCP Server
Archon crosses 1,000 pages. MCP server goes live.
Spring Boot (55 pages)
- Fundamentals — Core concepts, REST API, exception handling, auto-configuration
- Data Access — Spring Data JPA, Hibernate tuning, Flyway/Liquibase migrations, QueryDSL, multi-datasource
- Security — Spring Security, JWT auth, OAuth2/OIDC, advanced security (@PreAuthorize, RBAC, audit logging)
- Cloud & Microservices — Spring Cloud Gateway, Config Server, Eureka, Resilience4j, distributed tracing
- Messaging — Spring Kafka, Spring Integration (Enterprise Integration Patterns)
- Web & API — WebSocket/STOMP, GraphQL, gRPC, API versioning, OpenAPI/Swagger, file uploads
- Batch & Integration — Spring Batch deep dive, Spring Integration, event-driven architecture
- Advanced — Spring WebFlux/Reactor, Spring Modulith, State Machine, AOT/GraalVM native image, virtual threads (Project Loom), Spring AI (LLM integration)
- Operations — Actuator, Micrometer observability, Docker, Kubernetes deployment, caching, logging
- Reference — Best practices, anti-patterns, migration guide (Boot 2→3), cheat sheet
Data Pipeline (25 pages)
- Collection — Web scraping (Scrapy), API ingestion, database extraction (CDC/Debezium), file formats (CSV/Parquet/Avro)
- Preprocessing — Pipeline architecture, type inference, string/numerical/categorical/datetime/text/image preprocessing, deduplication, advanced imputation (KNN/MICE/MissForest)
- Orchestration — Airflow DAGs, Prefect flows, pipeline design patterns, monitoring & alerting
- Validation — Great Expectations, Pandera schemas, data contracts
- Projects — E-commerce pipeline, real estate pipeline, IoT streaming pipeline
MCP Server
- 21 tools — search, get_page, list_sections, get_related, list_pages, get_cheat_sheet, search_by_tag, search_by_difficulty, get_comparison, get_interview, get_lld, get_war_room, get_checklist, get_runbook, get_learning_path, get_glossary_term, get_code_examples, random_page, get_build_guide, get_eda_guide, list_all_tags
- 3 MCP resource templates — sections, cheat sheets, learning paths
- 5 MCP prompts — explain-concept, interview-prep, debug-issue, compare-tech, eda-workflow
- Remote endpoint —
https://archon.ayushjadaun.com/api/mcp - npm publishable as
archon-mcp-server - Rate limiting — 60 requests/minute
- Smithery config for marketplace listing
March 24, 2026 — The EDA Expansion
+69 EDA pages. Archon reaches 950+ pages.
Exploratory Data Analysis (69 pages)
- EDA Mindset (5) — Philosophy, asking right questions, 10-step workflow, 30+ common mistakes, domain-specific EDA
- Data Understanding (6) — Data types, shapes, collection, profiling, distributions, scale
- Data Cleaning (7) — Missing data (MCAR/MAR/MNAR), outliers, text cleaning, datetime hell, categories, validation, 20 edge cases
- Univariate Analysis (4) — Numerical, categorical, temporal, text
- Bivariate & Multivariate (5) — Num-num, cat-num, cat-cat, multivariate, correlation traps (Simpson's paradox)
- Feature Engineering (6) — Transformations, encoding (12 strategies), creation, datetime, text, scaling
- Special Situations (5) — Imbalanced data, multicollinearity, high cardinality, large datasets (Dask/Polars), small datasets
- Libraries (8) — NumPy, pandas (2), matplotlib, seaborn, plotly, scipy, polars
- Streamlit (3) — Basics, full interactive EDA app (300+ lines), automated EDA tools
- Real-World Projects (5) — Titanic, e-commerce (RFM/cohort), financial (stocks/risk), healthcare (survival), NLP (sentiment/topics)
- Reference (4) — 60-item checklist, chart decision tree, statistical test selector, pandas cheat sheet
- Advanced (11) — Geospatial EDA, image/audio EDA, data leakage, sampling strategies, post-modeling EDA, SHAP/LIME explainability, reproducibility, communicating findings, statistical power, relational data, data drift, ethics & bias
March 20, 2026 — The Mega Expansion (Part 2)
+200 more pages. Archon reaches 850+ pages.
Wave 2 New Sections
- War Room (12 pages) — Real production incidents: GitHub, Cloudflare, Knight Capital, AWS S3, Facebook, GitLab, Stripe, Discord, Twitter, Netflix, CrowdStrike
- Security Exploits (12 pages) — XZ Backdoor, Log4Shell, SolarWinds, Heartbleed, Spectre/Meltdown, Dirty Pipe, container escapes, advanced injection/XSS, cloud misconfigs, crypto attacks
- Cybersecurity Path (22 pages) — Complete security engineer training: networking, pentesting, Linux security, network attacks, reverse engineering, crypto hacking, cloud pentesting, OSINT, forensics, secure coding, tools, Active Directory, red/blue team, Web3 security, mobile security, bug bounty, malware analysis, certifications
- Deep Auth System (12 pages) — Enterprise auth architecture, token strategies (DPoP, macaroons), OAuth 2.1 flows, session management, account sharing prevention, enterprise SSO (SAML/SCIM), passkeys/WebAuthn, MFA deep dive, auth providers comparison, advanced rate limiting, device trust/risk engine, auth attacks & defenses
- LLD Interview Problems (12 pages) — Parking lot, elevator, chess, library, snake & ladders, vending machine, ATM, movie booking, hotel, file system, tic-tac-toe
- Debugging Playbooks (7 pages) — "API is slow", "memory leak", "database CPU 100%", "pods restarting", "intermittent 502s", "error rate spiked"
- Production Checklists (5 pages) — Pre-launch (90 items), security review, performance review, observability readiness
- Runbook Collection (5 pages) — Database failover, service degradation, certificate rotation, DDoS response
- Mobile Engineering (6 pages) — React Native, Flutter, mobile performance, push notifications, offline-first
- Build From Scratch (5 pages) — Build Redis, rate limiter, key-value store, load balancer from scratch
- Company Architecture (5 pages) — How Uber, Figma, Shopify, Discord actually built their systems
- Migrations (4 pages) — Zero-downtime database migrations, monolith→microservices, cloud migration
- Background Jobs (4 pages) — Temporal, BullMQ vs Celery vs Sidekiq comparison, job patterns
- Geospatial (2 pages) — Spatial indexing (geohash, S2, H3, PostGIS), geofencing
- Real-Time Analytics (2 pages) — ClickHouse vs Druid vs Pinot, stream-to-OLAP
- AI Infrastructure (3 pages) — GPU K8s, model serving (vLLM, Triton), AI infra overview
Wave 2 New Pages in Existing Sections
- AI/ML (18 new) — LangChain (2000+ line mega guide), LangGraph (2200+ line mega guide), LangSmith, LlamaIndex, Vercel AI SDK, fine-tuning (LoRA/QLoRA), AI guardrails, AI in production, multimodal AI, prompt caching, advanced prompt engineering, data annotation, Claude API, OpenAI API, Hugging Face, CrewAI/AutoGen, AI testing
- System Design Interviews (8 new, 48 total) — ChatGPT, Copilot, Recommendation Engine, Fraud Detection, Search Ranking, Content Moderation, Twitter Search, Typeahead, Live Streaming
- Algorithms (8 new) — JS interview (50+ questions), React interview, Node.js interview, probability, statistics/A/B testing, greedy, bit manipulation, string algorithms, advanced DS, system design math
- Schema Design (4 new) — E-commerce, social media, SaaS multi-tenant, chat schemas
- Infrastructure — Deno/Bun, TypeScript patterns, Python data tools, Python async, API gateway, storage systems
- Security — Supply chain security, cryptography for engineers
- DevOps — Feature flags, open source, tech debt, postmortem template, technical leadership, hiring, RFC template, design doc template, observability tools, release engineering, debugging in production
- Performance — Benchmarks reference, continuous profiling, compilers/interpreters, load testing
- Frontend — Data visualization, i18n, WCAG compliance
- Cheat Sheets (6 new, 22 total) — SQL advanced, Docker Compose, LLM APIs, terminal productivity, HTTP clients
- Learning Paths (2 new) — Engineering resources, behavioral interviews
- Production Blueprints — Email service, scheduler service, webhook infrastructure, file processing
- API Design — gRPC deep dive, event-driven APIs, API gateway patterns, GraphQL advanced
Infrastructure
- CI Node heap bumped to 24GB with 1GB semi-space for 850+ pages
March 20, 2026 — The Mega Expansion (Part 1)
+179 new pages in a single session. Archon goes from 470 to 650+ pages.
New Sections
- Algorithms & Data Structures (10 pages) — arrays, linked lists, trees, graphs, dynamic programming, sorting, heaps, hash tables, backtracking
- AI/ML Engineering (7 pages) — LLM integration, RAG architecture, vector databases, embeddings, AI agents, ML pipelines
- Testing (8 pages) — unit, integration, E2E, contract, property-based, TDD/BDD, test architecture
- Frontend Engineering (7 pages) — web performance, browser rendering, SSR/SSG/ISR, state management, micro-frontends, bundle optimization, React internals, WebAssembly
- SOLID Principles (6 pages) — SRP, OCP, LSP, ISP, DIP with TypeScript/Go/Python examples
- Functional Programming (4 pages) — core concepts, monads/functors, FP in TypeScript
- Concurrency & Parallelism (4 pages) — lock-free data structures, actor model, real-time systems
- SRE (5 pages) — error budgets, toil reduction, capacity planning, SLI/SLO/SLA
- Compliance (5 pages) — GDPR engineering, SOC 2, PCI DSS, audit logging
- Authorization (4 pages) — RBAC/ABAC/ReBAC, Google Zanzibar, OPA & Cedar
- Multi-Tenancy (3 pages) — database strategies, noisy neighbor
- Platform Engineering (3 pages) — Backstage, developer experience, DORA metrics
- FinOps (3 pages) — cost optimization playbook, cost allocation & tagging
- Data Lakehouse (4 pages) — Delta Lake/Iceberg/Hudi, medallion architecture, query engines
New Pages in Existing Sections
- System Design — rate limiting, circuit breaker, bloom filters, distributed locking, leader election, queueing theory, search engineering, GraphQL vs REST, concurrency
- Databases — DynamoDB, Cassandra, Elasticsearch, ClickHouse internals
- API Design (7 pages) — REST best practices, versioning, OpenAPI/Swagger, pagination, webhooks, API security patterns, GraphQL advanced
- Infrastructure — Nginx deep dive, service mesh, observability, Node.js internals, Go concurrency, Rust for backend, TypeScript advanced, Linux internals (4 pages), eBPF
- Networking — QUIC protocol, WebRTC, MQTT
- Kubernetes — CRDs & operators, admission webhooks, CNI plugins, GitOps (ArgoCD & Flux)
- Message Queues — Kafka Streams, Kafka Connect
- Event-Driven — transactional outbox, idempotent consumers
- DevOps — Git internals, branching strategies, monorepo management, technical writing, code review, ADRs, on-call handbook, release engineering, debugging in production, disaster recovery
- Performance — load testing deep dive, compiler/interpreter basics
- Frontend — i18n & l10n
- Storage Systems — block/file/object storage, distributed file systems (HDFS, Ceph, MinIO)
10 New System Design Interviews (40 total)
- Design GitHub, Slack, Zoom, Reddit, Airbnb, LinkedIn Feed, Google Docs, Leaderboard, Ad Platform, CDN
6 New Production Blueprints (14 total)
- Search service, feature flag service, chat service, file storage, audit log, config service, payment engineering (ledger + reconciliation)
4 New Learning Paths (9 total)
- Data Engineer, AI/ML Engineer, Platform Engineer, Full-Stack Engineer
11 New Cheat Sheets (19 total)
- Python, Go, Rust, Bash, Nginx, PromQL, AWS CLI, kubectl advanced, Helm, GraphQL, Regex
Infrastructure
- Bumped CI Node heap to 20GB with 512MB semi-space for GC optimization
- Bumped CI swap to 16GB with expanded disk cleanup
- Updated nav with new Engineering sections (Testing, AI/ML, Frontend)
March 19, 2026 — The Archon Update
- Rebranded from Knowledge Vault to Archon
- Added AI Chatbot (Oracle of Archon) — Pagefind retrieval + Gemini 2.5 Flash with page citations
- Added Interactive Knowledge Graph — visual map of all 470+ topics with radial cluster layout
- Added Compare Mode — side-by-side tech comparison with 24 technologies
- Added Keyboard Shortcuts — press
?to see all shortcuts - Added Bookmarks system — save pages, view at
/bookmarks - Added Verification System — verified/unverified badges with GitHub avatar + LinkedIn chip
- Added Start Here roadmap — guided paths for interviews, backend, devops, security
- Added Reading Time indicator on every page
- Added Reading Progress tracker per learning path
- Added Reading Streak — tracks daily visits
- Added "Was this helpful?" feedback widget
- Added Focus Mode — distraction-free reading (full width, Esc to exit)
- Added Font Size Controls — A-/A+ buttons
- Added Quick Notes — per-page notepad saved in localStorage
- Added Scroll Progress Bar — gradient bar at top of page
- Added Back to Top ring — circular progress indicator
- Added Copy Heading Links — click any heading to copy URL
- Added Code Copy Toast — "Copied!" feedback on code blocks
- Added Difficulty Badges — colored dots in sidebar with legend
- Added SEO + Open Graph meta tags for social sharing
- Added PWA support — install as an app for offline reading
- Added RSS feed at
/feed.xml - Added Changelog page (you're reading it)
- Added Verification Guide at
/verify - Fixed cross-references in all 16 prompt engineering pages
- Fixed mobile responsiveness — mermaid diagrams, tables, code blocks
- Fixed outline tracking — "On this page" highlights current heading
- Cinematic homepage with Lincoln quote and Feynman footer
- New Archon logo — hexagonal vault with anime-style keystone
March 18, 2026
- Added 30 System Design Interview walkthroughs (Instagram, Uber, YouTube, WhatsApp, Netflix, Spotify, and 24 more)
- Added 5 Learning Paths (Backend, DevOps, Frontend, Security, Interview Prep)
- Added 8 Cheat Sheets (Docker, K8s, Git, SQL, TypeScript, Linux, Redis, Terraform)
- Added Technology Radar with 29 technologies
- Added Related Pages component — auto-shows related content at bottom of every page
- Added Tag Browse page — explore all 1,240 tags with difficulty filter
- Added Interactive Code — "Run" button on TypeScript code blocks (opens in StackBlitz)
- Switched to Pagefind search (post-build, no memory impact)
- Fixed {{ }} Vue template syntax errors across 32 files
- Fixed GitHub repo links in navbar and edit links
- Improved sidebar — all sections expanded by default, auto-scroll to active page
March 17, 2026
- Initial release — 187 pages across System Design, Architecture, Infrastructure, Security, DevOps, Performance, and Data Engineering
- Added 147 new pages in one session (System Design networking, Architecture patterns, K8s, Docker, AWS, GCP, CI/CD, Multi-region, Security, DevOps, Performance, Data Engineering, Prompt Engineering)
- Total reached 334 pages
March 16, 2026
- Project created with VitePress
- Initial scaffolding — System Design, Databases, Caching, Consensus, Architecture, Security, DevOps, Infrastructure, Performance sections