$ ls courses/
Structured, multi-part courses grouped into learning tracks. Pick a track, follow the courses in order, and work through each one lesson by lesson.
Clearing MAANG Interviews
Coding patterns, system design, and behavioural rounds: everything a big-tech interview loop tests, in the order to study it.
Coding Interview Patterns — Crack the Coding Round
A complete, pattern-based coding-interview course for programmers: the ~18 reusable patterns (two pointers, sliding window, fast & slow pointers, hash maps, prefix sums, merge intervals, monotonic stack, binary search, linked-list reversal, tree BFS/DFS, heaps, backtracking, graphs, 1-D and 2-D dynamic programming) that cover the large majority of LeetCode-style questions. Each pattern has an easy explanation, a diagram, a Python code template, and representative questions with worked solutions. Every solution in the course is tested and runs.
Cracking the System Design Interview
A complete crash course to ace your system design interview. From frameworks and estimation techniques to designing real systems like WhatsApp, YouTube, Uber, and more — with architecture diagrams, API designs, and deep dives into scalability.
Cracking the Behavioural Interview
A complete, practical course for the behavioural interview at MAANG and other top tech companies: the hidden scoring rubric, the STAR method, how to build a reusable story bank, Amazon's Leadership Principles, the common questions by theme, company-by-company playbooks, the mistakes that sink candidates, and a two-week prep plan — with worked example answers.
$ subscribe --weekly
Get the next course in your inbox
One deep dive a week: new lessons, system designs, AI engineering and trading systems. Free, unsubscribe any time.
or read it on gyanbyte.substack.com
AI, LLMs & Agents
Build with large language models: from the first API call to RAG, agents, voicebots, and serving open models in production.
AI for Developers — Build with LLMs, RAG & Agents
A practical crash course for programmers who want to build with LLMs — API calls, prompt engineering, RAG, LangChain, model selection, and production patterns. No ML theory, just working code.
Become an AI Engineer — Practical Guide
A hands-on crash course that takes you from zero to building production-grade AI applications. Build an LLM playground, RAG-powered chatbot, web search agent, deep research system, and multi-modal generator — all with real code and modern AI APIs.
LLM Engineering in Production
A hands-on crash course for engineers shipping LLM-powered applications. Covers everything from how LLMs work to RAG pipelines, prompt injection defenses, AI agents, cost optimization, and observability — with production code throughout.
AI Agent Development — From First Loop to Production
A practical, no-hype course on building AI agents that survive real users. Write the agent loop from scratch, design tools, manage memory, control cost, debug with traces, evaluate trajectories, lock down security, and scale to thousands of concurrent runs, with every pitfall I have hit along the way.
Open LLMs in Production — Serving, Quantization, Fine-Tuning and Cost
Running open-weight language models yourself, properly. How inference uses your hardware, the memory maths of weights and KV cache, quantization, serving engines like vLLM and llama.cpp, batching and throughput, latency and prefix caching, the real cost in rupees vs an API, fine-tuning with LoRA and QLoRA, evaluation, scaling on Kubernetes, and security. Every number comes from a real measurement, a real model config, or a clearly-marked estimate.
Building Voicebots — Telephonic & Browser, the Real Engineering
A practical course on building production voicebots for India: the STT→LLM→TTS loop, phone (PSTN/SIP) vs browser (WebRTC) channels, WebSocket vs WebRTC and when to use each, streaming STT and TTS (Sarvam, ElevenLabs, Deepgram, Whisper), prompting an LLM for voice, orchestrating with Pipecat, latency and barge-in, RAG vs structured data vs plain prompts, real use cases (government schemes helpline, visitor management/gatepass, support, outbound), cost engineering to make it cheap (with worked ₹/minute math), production operations, and privacy/compliance (DPDP, call recordings).
Backend & Distributed Systems
Design, build, and run backend systems at scale: databases, queues, caches, cloud, security, and debugging in production.
System Design Masterclass
A comprehensive system design course for software engineers — from fundamental scaling patterns to real-world design problems. Covers caching, sharding, load balancing, message queues, distributed transactions, and classic interview problems with architecture diagrams and working examples.
Distributed Systems in Practice — Failures, Time, Consensus and Correctness
What really happens when your code runs on more than one machine. Timeouts and retries, idempotency, clocks, replication and quorums, consistency models, Raft, consistent hashing, distributed locks, delivery guarantees, the outbox pattern and cascading failures. Every failure is reproduced on a real etcd cluster, real Redis, or a simulation you can run.
Database Internals for Backend Engineers — PostgreSQL in Depth
Understand what your database is really doing. How PostgreSQL stores rows, how indexes work, how to read EXPLAIN, why the planner picks bad plans, MVCC, VACUUM, isolation levels, locks, WAL, replication and scaling. Every example runs on a real 20 lakh row table.
Redis — The In-Memory Data-Structure Store, End to End
A practical, measurement-grounded course on Redis for backend engineers: what Redis is (an in-memory, single-threaded data-structure store), the core data structures (strings, lists, hashes, sets, sorted sets, streams) and when to use each, keys/expiry/memory and eviction, caching patterns and their traps, pipelining and transactions, pub/sub and streams, persistence (RDB vs AOF), replication and Sentinel HA, Redis Cluster and sharding, distributed locks and coordination, advanced patterns (leaderboards, rate limiting, HyperLogLog, bitmaps, geo), and operating Redis in production. Grounded in REAL redis-benchmark numbers: ~100k ops/sec per instance, pipelining 16–25x, sub-millisecond latency.
Apache Kafka — The Distributed Log, End to End
A practical, measurement-grounded course on Apache Kafka for backend and data engineers: what Kafka is (a distributed commit log, not a queue), the data model (topics, partitions, offsets), producers (keys, acks, batching, idempotence), consumers and consumer groups, delivery semantics and exactly-once, replication and durability (ISR, acks, min.insync.replicas), storage/retention/compaction, KRaft architecture, the ecosystem (Connect, Schema Registry, Streams, ksqlDB), stream processing, operating in production, and the patterns where Kafka fits — and where it doesn't. Grounded in reproducible numbers: partition skew 7.6x, consumer-group parallelism caps, delivery-semantics dedup, RF durability, and disk-sizing arithmetic.
Data Engineering: Building Data Pipelines — From Raw Events to a Trustworthy Warehouse
A practical, measurement-grounded course on building data pipelines: what data engineering is (and OLTP vs OLAP), batch vs streaming, ingestion and change data capture, file formats and compression (row vs columnar — measured), lakes/warehouses/the lakehouse, partitioning and file layout (pruning and skew — measured), ETL vs ELT and dimensional modelling, distributed processing and the shuffle, streaming with Kafka, orchestration and incremental processing (measured), data quality and reliability (dedup — measured), and serving, cost and governance. Grounded in real measurements: Parquet column scans 6.8x faster than CSV, partition pruning 8x, data skew 5.9x, a 4.8% duplicate stream deduped cleanly, DuckDB aggregating 31M rows/sec.
Node.js Backend Engineering
A comprehensive crash course covering everything you need to build production-grade backend systems with Node.js — from the event loop to deploying on AWS.
Go for Backend Engineers — Concurrency, Simplicity and Real Numbers
A practical, measurement-grounded course on Go for people who build backend services: why Go's boring-on-purpose design pays off, Go fundamentals fast (explicit errors, no exceptions), implicit interfaces and composition over inheritance, goroutines and the M:N scheduler, channels and CSP, concurrency patterns (worker pools, fan-in/out, context cancellation), sync vs atomic and the race detector, building an HTTP service with net/http, testing and tooling, databases with database/sql and the connection pool, taking a service to production (graceful shutdown, config, structured logs, one static binary), and performance and memory (escape analysis, GC, allocations). Grounded in real Go 1.24 measurements — 1,000,000 goroutines in 586 ms, 12.3M channel messages/sec, mutex vs atomic, stack vs heap allocation.
Kubernetes for Backend Engineers — Pods, Scaling, Networking and Production
Kubernetes explained the way a backend engineer needs it: the control-loop model, the cluster, pods, Deployments and rolling updates, requests and limits (with real OOM-kill and CPU-throttle experiments), the scheduler, Services and Ingress, config and secrets, probes and self-healing, autoscaling, storage and StatefulSets, and production security. Container behaviour is measured for real; control-plane logic is shown with faithful simulations and real kubectl output.
AWS for Backend Engineers
A practical crash course on AWS for backend engineers — from IAM and Lambda to multi-region architecture. No console-clicking tutorials. Real patterns, real tradeoffs, real code.
Observability & Production Debugging — From the Three Pillars to Debugging a Live Incident
A practical course on seeing into production systems and debugging them fast: monitoring vs observability, the three pillars (logs, metrics, traces) and how they work together, structured logging, metric types with RED/USE and the four golden signals, distributed tracing and the trace waterfall, OpenTelemetry, dashboards that aren't noise, alerting without fatigue, SLOs and error budgets, a repeatable incident-debugging workflow, performance debugging (percentiles, tail amplification, flame graphs), and the cost/cardinality engineering that keeps the observability bill sane. Grounded in real measurements.
Security Engineering for Backend Engineers — Threats, Auth, Crypto and Shipping Securely
Application and backend security the way an engineer needs it: thinking like an attacker (threat modeling, STRIDE), authentication done right (password hashing measured for real, MFA, sessions vs tokens), authorization and IDOR/BOLA, injection, the web attacks (XSS, CSRF, SSRF) and the headers that stop them, cryptography without rolling your own, secrets and key management, API security and rate limiting, supply-chain and CI/CD hardening, cloud IAM and defense in depth, logging and incident response, and secure SDLC with India's DPDP Act. Grounded in OWASP and real, reproducible measurements.
Payments Engineering in India — From UPI to Ledgers
A practical course for engineers who build payment systems in India. Learn how UPI and cards really work, integrate a payment gateway the right way, handle pending payments and webhooks, design a double-entry ledger, do reconciliation, and stay safe with fraud and RBI rules.
Trading & Finance for Programmers
Markets explained for engineers: options, futures, crypto derivatives, and the low-latency systems that trade them.
Options Trading for Programmers — A Fundamentals Course
A fundamentals-to-slightly-advanced options trading course written for techies: calls and puts, moneyness and payoffs, the Greeks, Black-Scholes pricing and implied volatility, volatility itself (HV/IV, India VIX), directional strategies, spreads, advanced structures (straddle, strangle, iron condor, butterfly), risk and position sizing, the data & broker-API tooling stack, and building a simple options algo end to end. Indian market context (NSE, Nifty, lot sizes, STT), real Black-Scholes numbers, and Python you can run. Educational only, not financial advice.
Futures & Commodities Trading for Programmers
A fundamentals-to-slightly-advanced course on futures and commodities trading for programmers: what a future is, the linear payoff, cost-of-carry pricing and basis, contango vs backwardation, the commodity universe (NSE index/stock futures + MCX bullion/energy/metals), margin, daily mark-to-market and leverage, rollover and term structure, directional strategies, spreads and arbitrage, hedging, risk and position sizing, the data/broker-API tooling stack (and the continuous-contract trap), and building a simple futures algo. Real cost-of-carry, margin and roll numbers, Python you can run, Indian (NSE/MCX, SPAN margin, STT/CTT) context. Educational only.
Crypto Options & Algo Trading for Programmers
A fundamentals-to-slightly-advanced course on algorithmic crypto trading and crypto options, written for programmers: crypto market structure, perpetual futures and funding rates, crypto options (Deribit, BTC/ETH), the Greeks and volatility in crypto, income and directional strategies, basis & funding (delta-neutral yield) trades, DeFi options, the brutal risk landscape, the data & exchange-API tooling stack (CCXT, Deribit, Binance), and building a simple crypto algo. Real BTC Black-Scholes and funding numbers, Python you can run, Indian tax/regulation context. Educational only — crypto is extremely risky and largely unregulated.
Low-Latency Trading Systems & Algo Trading — From the Order Book to a Live Retail Algo
How electronic trading systems really work and how to build an algo responsibly: the limit order book and matching engine, market data (ticks vs depth, WebSocket practices), the low-latency engineering (ring buffers, lock-free vs thread locks, C++ vs Python — all measured), the latency stack and co-location, ultra-low-latency hardware (FPGA, kernel bypass, microwave, direct lines), a real system architecture (React, Python, C++, Redis, PostgreSQL), a multi-broker framework, honest backtesting, strategies including options selling, transaction costs and slippage, trading psychology, and taking a retail algo from paper to live — and onto crypto. Grounded in real, reproducible measurements. Educational, not financial advice.
Foundations & Career
Language crash courses and the skills that take you past senior.
Learn Python — A Crash Course for Programmers
A fast-track Python crash course for developers who already know another language. Skip the 'what is a variable' fluff — go straight to Python's unique features, idioms, and power tools.
React.js Crash Course for Backend Engineers
Everything a backend engineer needs to become productive in React — no fluff, no beginner hand-holding. Go from server-side thinking to building real React apps in 12 focused lessons.
The Staff Engineer Track — Scope, Influence, Strategy and Judgment
The craft of senior technical leadership on the individual-contributor path: what a staff engineer actually does, operating at the right altitude, technical strategy, writing that changes decisions, making good technical decisions, driving cross-team projects, influence without authority, glue work and leverage, mentorship and sponsorship, technical health, incidents and judgment, and getting to staff and staying effective. With reusable templates: design doc, ADR, project one-pager, incident review, brag doc.
Coming soon: Machine Learning · Object-Oriented Design