Engineering deep dives, not tutorials.
System design, distributed systems, and production patterns for engineers who build at scale.
Latest Articles
Fresh deep dives into system design, security, and engineering.
Execution Algorithms: VWAP & TWAP in Python
How you actually fill a big order without moving the market against yourself: TWAP (even slices over time) and VWAP (slices that follow the volume curve). The Python to build both schedules, a simulated impact comparison, and why execution — not alpha — often decides whether a strategy makes money.
Position Sizing & the Kelly Criterion in Python
How much to bet is a bigger decision than what to bet on. The Kelly criterion, fixed-fractional sizing, and why betting past Kelly lowers your growth AND makes ruin near-certain — demonstrated in Python, with the measured reason professionals bet half-Kelly.
Momentum & Trend Following in Python
Momentum — owning what's been rising and stepping aside when trends roll over — explained and backtested in Python. Time-series momentum and breakouts, the full code, and the signature result: its edge is defensive, cutting a −39% buy-and-hold drawdown to −25% by going to cash in crashes.
Mean Reversion & Pairs Trading in Python
Trade the spread, not the market: how pairs trading uses the z-score of two cointegrated assets to go market-neutral. The full Python — hedge ratio, spread, z-score, entry/exit at ±2σ — plus an honest look at why it works on paper and where it breaks (cointegration decay).
The Moving-Average Crossover, Backtested Honestly in Python
The 'hello world' of algo trading — the SMA crossover — built as a clean vectorised backtest in pandas, with the full code, the metrics that matter (CAGR, Sharpe, max drawdown), and an honest result: on a 6-year test it lost to buy-and-hold, because a crossover is a trend filter, not an edge.
Market Making Basics: Spread Capture vs Inventory Risk (in Python)
How market makers earn the spread by quoting both sides of the book — and why inventory is the risk that can wipe out every spread they capture. A toy market maker in Python, and the single most important control: skewing your quotes against inventory (measured: |max inventory| 90 → 3).
Depth you can actually trust
Every course and guide is grounded in real, measured experiments — not hand-waving — explained in plain English with detailed diagrams. Written for engineers who build at scale, and free for everyone.
Real measurements
Benchmarks and experiments, not hand-waving.
Detailed diagrams
Every concept drawn, readable in light & dark.
Plain English
Written for working engineers. No fluff.
Free & open
Every course and guide, free forever.
Crash Courses
Structured, multi-part deep dives — zero to confident, at your own pace.
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.
Start learning arrow_forward
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.
Start learning arrow_forward
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.
Start learning arrow_forward
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.
Start learning arrow_forward
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.
Start learning arrow_forward
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).
Start learning arrow_forwardWhat I Write About
24 full courses, 275 lessons
From system design, security and databases to Go, data engineering and low-latency trading — structured, measured, and free to work through at your own pace.
More Articles
Browse All arrow_forward
Order-Book Imbalance: A Microstructure Signal (in Python)
The HFT bread-and-butter signal, explained honestly: order-book imbalance — more size on the bid than the ask tilts the odds of the next price tick. The Python to compute it and test its predictive power, why it genuinely works, and why it's so hard to actually harvest.
Market Data: Types & Where to Download It (Free and Paid)
A practical guide to market data for algo trading: the levels (OHLCV bars, L1 ticks, L2 depth, L3 full book), free sources you can start with today (yfinance, Stooq, crypto exchange APIs, NSE/BSE bhavcopy), paid sources for real money (Polygon, Databento, Kite Connect), and the two biases that quietly wreck backtests — with Python to pull data.
Algo Trading Vocabulary — The Cheat-Sheet That Unlocks Everything
A one-page vocabulary for algorithmic and HFT trading: the order book (bid, ask, spread, depth, L1/L2/L3), the order types you actually send (market, limit, stop, IOC/FOK/GTC, maker/taker), and the rest of the words — slippage, VWAP, Sharpe, drawdown — explained plainly.
Pull Request Best Practices in the AI Era
Why small, focused, self-reviewed pull requests matter more than ever now that AI can generate a 500-line diff in seconds. The anatomy of a PR that's easy to say yes to — clear description, green CI, one concern — and the research-backed reason to keep it under ~400 lines.
Git Commit Best Practices in the AI Era
How to write commits that explain themselves — atomic changes, a subject that says what and a body that says why, conventional commits — and the new discipline the AI era demands: reviewing and splitting AI-generated diffs before you commit, because you are still the author of record.
Code Review Best Practices in the AI Era
How to review code well when a machine wrote it and the CI is already green: the layered review (let automated gates and AI bots catch the mechanical; save humans for judgment), and the new failure mode — automation complacency — where reviewers rubber-stamp fluent, confident, subtly-wrong AI code.
Idempotency in Distributed Systems — Why Your Retry Just Charged the Customer Twice
A practical guide to idempotency: why retries cause double charges, how idempotency keys and dedup stores fix it, delivery semantics (at-least-once vs exactly-once), and how to make non-idempotent operations like payments safe.
Message Queue vs Stream — RabbitMQ/SQS vs Kafka, and When to Use Which
The real difference between a message queue (RabbitMQ, SQS) and an event stream (Kafka): consume-and-delete vs append-and-keep, how each scales consumers, delivery and ordering guarantees, and a simple test for choosing the right one.
Vector Databases & Embeddings, Explained — From Text to Similarity Search
A clear guide to embeddings and vector databases: what an embedding really is, how approximate nearest-neighbour (ANN) search and HNSW make similarity search fast at scale, and when you actually need a dedicated vector DB versus pgvector or plain brute force.
Ready to build something together?
I take on 1-2 projects at a time. Let's talk about your next challenge.
Hire Me