Articles
All published writing, newest first.
Filters
398 articles
Newest firstGoogle and Kaggle Gen AI study notes — the opening foundations
An opening-reading notebook, not a completed five-day course: distinguish recurrence, attention, autoregressive generation, prompting, retrieval and fine-tuning.
8 min readApache Airflow - open source orchestration engine
Design retry-safe Airflow tasks without mistaking DAG ordering for a database transaction. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
19 min readApplied LLMs — origins, evidence and applications
A readable route through LLM foundations, attention, retrieval, prompting, audio, clinical NLP, statistical learning and deployment responsibilities.
12 min readVariant contracts: bounded budgets, interval cuts and subset routes
Extend the restored problem-family series with bounded knapsack, two resource budgets, interval reconstruction and Held–Karp routes, using independent tiny oracles.
30 min readData Infrastructure for AI and Experimentation at Scale
Trace events, time-valid features, recommendation decisions and experiment outcomes through a source-reviewed data platform with executable SQL and statistical fixtures.
55 min readData Platform & Orchestration
A data platform is a chain of independently testable contracts. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
8 min readDeep Learning and LLMs: an inspectable learning laboratory
A broad deep-learning and LLM progression with a verified NumPy spine, advanced framework and systems lessons, source evidence and explicit execution boundaries.
13 min readRecommendation quality starts before ranking
An executable retrieve-score-rerank pipeline that exposes candidate recall and diversity trade-offs.
11 min readDesigning for Scale · Requirements to Architecture
Convert prompts into testable requirements, capacity constraints and failure contracts through four worked designs and a traceable review method.
24 min readCapacity estimates that survive an overload question
Derive traffic, storage, bandwidth, working set and backlog with explicit units, sensitivity analysis and exact retained laboratory programs.
22 min readDesigning for Scale · The Storage Decision Tree
Storage selection has several independent axes. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
8 min readDesigning for Scale · CAP and the Consistency Spectrum
CAP is a history argument, not a database label. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readDesigning for Scale · URL Shortener
Identifier probability and redirect policy. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readToken buckets: bursts, clocks and the atomic boundary
Implement and test one token bucket, then identify what changes when several servers enforce the same quota.
12 min readDesigning for Scale · Chat and Real-time Communication
Transport, durable acceptance and per-conversation order. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readDesigning for Scale · Newsfeed and Fan-out
Hybrid fan-out is a workload decision, not a law. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
8 min readDesigning for Scale · Typeahead and Search Autocomplete
Prefix lookup, top-k maintenance and hot prefixes. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readDesigning for Scale · Notification Systems
The provider acknowledgement is an uncertainty boundary. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readDesigning for Scale · Real-Time Analytics
Provisional and final aggregates must agree on ownership. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
9 min readDesigning for Scale · Change Data Capture (CDC)
Build CDC and transactional-outbox reasoning around coordinated snapshots, durable intent, replay identity, schema evolution and WAL retention.
12 min readDesigning for Scale · The Data Lakehouse
Explain atomic table snapshots over immutable files, writer conflicts, row deletes, schema identity, maintenance and measured architecture trade-offs.
12 min readA metering ledger that survives a replay
Put event identity and usage aggregation in one transaction, then test rollback, duplicates and conflicting payloads.
12 min readHistorical features need two clocks
A point-in-time join lab that rejects future events and late backfills while preserving explicit TTL semantics.
12 min readDesigning for Scale · Model Serving
Budget model-serving queues, batching, memory and asymmetric scaling, then design bounded shadow deployments and controlled rollouts.
22 min readDesigning for Scale · RAG and Vector Search
Build versioned authorized retrieval, compare exact and approximate search, fuse lexical and vector candidates, and test evidence boundaries.
24 min readRelease gates need denominators, not reassuring scores
Combine deterministic checks, calibrated model judges, multimodal evidence and statistically explicit release gates without replacing human accountability.
24 min readDesigning for Scale · End-to-End Design Review I
Trace video upload, processing, publication, feed fanout and deletion through a worked capacity model and guarded state machine.
24 min readDesigning for Scale · End-to-End Design Review II
Protect ticket inventory through bounded admission, short transactions, durable holds and idempotent payment reconciliation with a SQLite state-machine fixture.
27 min readSystems laboratory: make the failure observable
A practical route from capacity estimates to replay-safe data, permission-aware retrieval and evidence-based release gates.
11 min readA deep-study prompt with examples, evidence and an audio version
Build a bounded study request, keep sources separate from narration, and evaluate generated explanations instead of mistaking fluent detail for verified knowledge.
10 min readOverall Engineering Clarity — Data, Distributed Systems and AI (Deep Dive)
Trace compute, commit, indexing and authorization boundaries across a data/AI platform. Mechanisms, worked examples, failure analysis and complete practice answers.
119 min readHow transformers actually attend — a weighted lookup you can calculate
Follow queries, keys and values through a numeric attention head, test causal masking, and separate multi-head capacity from guaranteed interpretability or long-context quality.
12 min readImage classification: from a scalar model to a tested experiment contract
Derive loss and softmax, plan controlled Fashion-MNIST experiments, and follow complete local TensorFlow references for training, callbacks and save/load.
30 min readReplay is a feature; duplicate effects are a design choice
Choose partition keys and independent groups for hot, warm and cold ML pipelines. Mechanisms, worked examples, failure analysis and complete practice answers.
12 min readKimi K3: architecture, derivations and a pinned-source audit
Derive KDA state updates, depth attention and latent expert routing; reconcile pinned Kimi architecture claims and execution limits.
56 min read01 · Programs as contracts: values, state and tests
Build a small event normalizer, expose aliasing, and distinguish a test from a proof. Python foundations without a catalogue of syntax.
14 min read02 · Count work, then remember what matters
Derive hash counting and prefix sums from repeated work, with brute-force oracles and honest complexity assumptions.
13 min read03 · Discarding possibilities: search and windows
Prove which candidates can be discarded, derive lower bound, and see exactly why negative numbers break a common window.
14 min read04 · Unfinished work: stacks, queues and heaps
Choose a removal policy, prove a next-greater stack, and maintain a bounded top-k heap without confusing partial order with sorting.
13 min read05 · Graphs: reachable is not ready
Derive unweighted shortest paths and dependency ordering, with explicit edge direction, cycle rejection and bounded exhaustive tests.
16 min read06 · Dynamic programming: choose a sufficient state
Derive take-or-skip recurrence, explain backward capacity updates, and distinguish exact amounts, capacity bounds and counting order.
16 min read07 · Relations, joins and all-or-nothing changes
Build an in-memory SQLite notebook, preserve zero-event jobs in a join, and test rollback without confusing it with crash durability.
15 min read08 · Retries: a timeout is not a verdict
Model a lost acknowledgement, define idempotent effects, and separate delivery, durable processing and response replay.
13 min read09 · Bounded work: queues, deadlines and ownership
Reason about backlog growth, choose an overload policy and distinguish admission, completion and cancellation without running a server.
12 min read10 · Capstone: a trustworthy local job notebook
Integrate validation, dependency checks, atomic event ingestion and retry tests. A runnable reference core and an evidence-based assessment rubric.
19 min readCapstone: an evidence service with replay-safe usage
Compose tenant-scoped retrieval, explicit abstention and a durable-event invariant into one executable failure lab.
6 min readBuilding a Learning System That Actually Sticks
Research-informed retrieval and spacing with a broad curriculum, honest schedule arithmetic, bounded review queues and no invented automation or mastery promises.
30 min readThe LeetCode Game — How to Read a Problem
Constraints are not decoration. They are a reviewer quietly telling you which complexity class is acceptable, and therefore which algorithm to reach for.
19 min readBig-O in Practice — Counting, Not Vibes
How to derive the cost of a Python data structure operation from how it is built, instead of memorising a table you half-remember under pressure.
16 min readPython for Speed — The 20 Idioms That Matter
The small set of standard-library tools that turn a fifteen-line design review solution into a five-line one, and the syntax you must be able to type without thinking.
15 min readArrays & Strings — In-Place Discipline
The read pointer and write pointer skeleton that solves a surprising share of Easy problems, and the index bookkeeping that makes it correct on the first try.
17 min readHashing — Your Default Weapon
The complement-lookup skeleton and the general move of trading memory for time, which is the first thing to try whenever a problem looks quadratic.
16 min readUMPIRE — The Problem-Solving Framework
A six-step process for the twenty minutes between reading a problem and having working code, so that being stuck becomes a step rather than a state.
18 min readTwo Pointers I — Opposite Ends
Two indices converging from the ends of a sorted array, and the monotonicity argument that proves you can discard a whole row of candidates with one comparison.
24 min readTwo Pointers II — Same Direction & Fast-Slow
Two pointers moving the same way at different speeds: the read/write compaction you already know, and Floyd's cycle detection, which finds a loop in O(1) memory.
18 min readSliding Window I — Fixed Size
Maintaining a window aggregate incrementally so that sliding costs O(1) instead of O(k), which turns the obvious O(n*k) scan into a single pass.
14 min readSliding Window II — Variable Size
Expand right unconditionally, shrink left while the invariant is broken, record at the right moment — and the amortisation argument that keeps it linear.
15 min readSliding Window III — With Counts
Windows whose validity depends on a frequency map, and the single integer counter that lets you test that condition in O(1) instead of rescanning the map.
17 min readPrefix Sums & Difference Arrays
Precomputing cumulative sums to answer range queries in O(1), and the prefix-plus-hashmap combination that counts subarrays where sliding windows are unsound.
16 min readBinary Search I — The Template
One binary search template with a half-open invariant that never loops forever and never goes off by one, and the discipline of owning exactly one version of it.
16 min readBinary Search II — Rotated & 2D
Binary search when the array is no longer sorted end-to-end: decide which half is still sorted, then discard the other. Same trick flattens a 2D matrix into one index space.
17 min readBinary Search III — On the Answer
Stop searching the array and start searching the answer range: define a monotonic feasibility predicate, then binary search the smallest x for which it holds.
17 min readStacks — LIFO & Matching
Nesting, matching, undo and expression evaluation are one idea: push what you expect, pop when it arrives, and carry auxiliary state alongside for O(1) queries like min.
19 min readMonotonic Stack
Next greater and next smaller element in O(n): keep a stack whose order never breaks, and pop everything the current element resolves.
23 min readQueues & Monotonic Deques
The queue as BFS substrate, and the monotonic deque that answers sliding-window maximum in O(n) by discarding candidates that can never win again.
25 min readLinked Lists I — Traversal & Reversal
The dummy head that deletes most linked-list edge cases, and the prev/cur/next three-step reversal you should be able to write without thinking.
20 min readLinked Lists II — Cycles, Middle, Reorder
Floyd's tortoise and hare for cycle detection and entry point, finding the middle in one pass, and composing split-reverse-merge to reorder a list in O(1) space.
20 min readRecursion & the Call Stack
Base case discipline, hand-tracing a call stack, and knowing when recursion is the wrong tool — the substrate under trees, backtracking and dynamic programming.
18 min readTrees I — DFS Traversals
Preorder, inorder and postorder as one recursive skeleton with the work line moved, plus the iterative forms and when they are worth writing.
19 min readTrees II — BFS / Level Order
Snapshot the queue length at the top of each iteration and you have level-order traversal — the one trick behind right side view, zigzag, and minimum depth.
19 min readTrees III — BST Properties
Two views of a binary search tree: inorder traversal yields sorted order, and validation requires passing bounds down rather than comparing parent to child.
21 min readTrees IV — Paths & Accumulators
The return-one-thing-track-another pattern: a recursion whose return value serves the parent while a separate accumulator records the global best.
21 min readHeaps & Top-K
When a problem asks for the K largest, K smallest, or K most frequent of anything, you almost never need to sort. A size-K heap answers it in O(n log k).
20 min readGraphs I — Representation & DFS
Build the adjacency list, carry a visited set, and recognise that a grid is already a graph — then count connected components with a depth-first sweep.
23 min readGraphs II — BFS & Shortest Path
Breadth-first search level by level, why it gives shortest paths in unweighted graphs, and the multi-source variant that solves nearest-X grid problems in one sweep.
19 min readGraphs III — Topological Sort
Kahn's in-degree algorithm for ordering tasks with dependencies, and why a queue that empties early is exactly a cycle detector.
18 min readGraphs IV — Union-Find (DSU)
Fifteen lines of disjoint-set union with path compression and union by rank, and the family of connectivity problems it collapses into near-constant time.
18 min readBacktracking I — Subsets & Combinations
One choose-explore-unchoose template that generates subsets, combinations and permutations, plus the two ways to skip duplicates without producing duplicate output.
19 min readBacktracking II — Constraint Grids
Pruning before you recurse, restoring board state exactly, and the O(1) validity checks that turn N-Queens and Sudoku from intractable into instant.
21 min readDP I — Recognising Overlapping Subproblems
DP is recursion plus a cache. Write the recursion, add lru_cache, convert to a table — mechanically, in that order, every time.
25 min readDP II — 1D Linear
Define dp[i] in English before you write code. The House Robber family, and why most DP bugs are undefined state rather than a wrong transition.
20 min readDP III — Take / Skip Decisions
The binary-decision DP shape: at each index you either act or you don't. State machines for cooldown, reachability for Jump Game, and split points for Word Break.
21 min readDP IV — Subsequences (LIS / LCS)
Longest Increasing Subsequence and Longest Common Subsequence are the two parent problems behind a huge family. Know both cold and most subsequence DP becomes recognition.
20 min readDP V — 0/1 Knapsack
Derive the 0/1 knapsack recurrence, prove why compressed capacity updates descend, and adapt the state to partition, sign assignments and reconstruction.
17 min readDP VI — Unbounded Knapsack
The knapsack where each item is available in unlimited supply. One character changes from 0/1 — the capacity loop direction — and Coin Change, Rod Cutting, and Combination Sum IV all fall out of it.
16 min readDP VII — 2D Grid
Grid DP is the friendliest dynamic programming: each cell is built from the one above and the one to its left. Use it to make DP feel mechanical before string DP.
19 min readDP VIII — String DP / Edit Distance
The two-string DP table: dp[i][j] over prefixes, the three-way insert/delete/replace recurrence, and how Distinct Subsequences and Interleaving String are the same table with different transitions.
21 min readDP IX — Palindromes
Expand-around-centre versus the 2D palindrome table: two O(n^2) approaches with very different failure rates, and when partitioning forces you back to explicit DP.
21 min readDP X — Interval DP
dp[i][j] over ranges with an inner split point k: why Burst Balloons only works when you think about the LAST balloon, and how sentinel padding removes the boundary cases.
23 min readDP XI — State Machine
Naming your DP states explicitly: hold and free arrays for the stock problems, why drawing the transition diagram first collapses the difficulty, and how the k-transaction version generalises.
24 min readDP XII — Bitmask DP
Encoding a subset as an integer: when n is at most 20 the exponential state is affordable, the standard submask and popcount idioms, and why the constraint tells you before the problem does.
20 min readTries — Prefix Trees
Children dict plus terminal flag: building a trie in ten lines, and why Word Search II is trie-plus-backtracking rather than a dictionary scan.
20 min readBit Manipulation
XOR cancels itself, n & (n-1) clears the lowest set bit, and how to add two integers without the plus operator. The handful of bit tricks that actually recur in practice.
23 min readMath & Number Theory
Fast exponentiation by squaring, the sieve of Eratosthenes, Euclid's GCD, and binary search on integers — the four math routines worth memorising outright.
26 min readIntervals
Sort by start, merge on overlap: the four-problem interval family, and why Meeting Rooms II needs a heap on top of the sort.
23 min readGreedy — And Proving It Works
Greedy feels right and is often wrong. The exchange argument, the counter-example hunt you should run first, and four problems where greedy genuinely is optimal.
27 min readMatrix Manipulation
Transpose then reverse to rotate in place, four-boundary control for spiral traversal, and using the first row and column as O(1) marker storage.
19 min readDesign I — Composing for O(1)
Hashmap plus doubly-linked list for LRU, array plus index map for GetRandom, and the general move of combining two structures so each covers the other's weakness.
20 min readDesign II — Streams & Time
Two balanced heaps for a running median, binary search over versioned timestamps, and merging k sorted feeds — the design patterns for data that arrives over time.
27 min readSorting & Custom Comparators
Partition-based selection and comparator design: Dutch national flag, quickselect for Kth largest in O(n) average, and cmp_to_key for orderings that are not a simple key.
23 min readSegment Trees & Fenwick (BIT)
Range query with point update in O(log n): the recursive segment tree skeleton, the Fenwick tree's low-bit trick, and how to recognise the rare problem that actually needs one.
20 min readString Algorithms
KMP's failure function, rolling hashes, and the Z-function — the three ways to avoid re-comparing characters you have already matched.
19 min readAdvanced Graphs
Dijkstra as BFS with a priority queue, Bellman-Ford for negative weights and bounded hops, and the two minimum spanning tree algorithms — with the cue for choosing between them.
19 min readMock Set 1 — Mixed Easy/Medium, 45 min
The first cold pressure test: two unseen Easy and two unseen Medium in 45 minutes, no hints, timer visible — run as an experiment that produces data about your classifier.
24 min readMock Set 2 — Narrated & Recorded
Two unseen Mediums solved entirely out loud, screen and audio recorded, then played back — the fastest available fix for design review communication.
24 min readBlind 75 Sweep — Gap Audit
Attempt-classify all 75 problems in one structured sweep, mark each cold, warm, hint or failed, and produce the personalised weak list that drives the rest of the track.
25 min readWeak-Pattern Intensive
Take the bottom three patterns from the L59 audit and repair them with the rebuild loop: blind template, three costumes, interleaved re-test.
24 min readMock Set 3 — One Hard, 45 min
Decomposing an unfamiliar Hard: find the seam where it splits into two Mediums, and practise being productive for 45 minutes without a full solution.
25 min readCompany-Tagged — Microsoft & Amazon
Work the frequency-ranked lists for the two companies that matter most to you, and adapt to each one's distinct review style rather than treating all loops as identical.
21 min readSenior-Flavour Coding
The hybrid round where coding meets design: rate limiters, LRU caches, schedulers and consistent hashing — built by composing primitives you already own.
18 min readContest Simulation
A real timed LeetCode weekly contest — the closest available replica of timed-contest pressure, and the only place to practise performing rather than solving.
24 min readFinal Audit + Maintenance Plan
Re-audit every pattern, compare against L59, and build the ongoing three-times-a-week loop that stops the whole thing decaying the moment the track ends.
28 min readAlgorithm practice · From recognition to a defensible solution
A broad problem-family route alongside the runnable Foundations Lab: derive invariants, study variants, test with oracles and track specific gaps.
22 min readWhere LLMs Came From, and What They Actually Are
A source-grounded history of language modelling, five core mechanisms and the boundaries between a predictor and a deployed assistant.
22 min readReading MEDEC — detection, localization and correction are different tests
Audit the MEDEC benchmark's data construction, exact reported scores, prompt format and metric limitations without treating a clinical NLP benchmark as deployment validation.
18 min readDiving deep into Tiktok recommendation engine
Explain full-key embedding admission, expiry and incremental synchronization. Mechanisms, worked examples, failure analysis and complete practice answers.
15 min readKusto and KQL — pipelines, safe queries and honest windows
Read KQL pipelines, reason about joins and aggregation, parameterize safe telemetry queries, and distinguish fixed bins from rolling windows.
24 min readReading OpenAI’s Math Repository: From Research Claims to Checkable Proofs
A deep guide to OpenAI’s math release: proof versus tests, rational approximation, zeta zero-free regions, Lean, and what formal verification does—and does not—establish.
30 min readRAG begins with an evidence boundary
Build permission-filtered retrieval and a deterministic evidence packet before asking a model to synthesize an answer.
24 min readLearning how to build an recommendation system from initial signals
Build candidate and propensity-model evaluation contracts without future leakage. Mechanisms, worked examples, failure analysis and complete practice answers.
20 min readRecommendation Systems From Scratch
Candidate recall, exposure bias and constrained ranking. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
5 min readR01 · Week 1 Recall & Drill
Week 1 revision: reproducible dev environments, Git's object model, shell pipelines, doc-hunting strategy, and Python's reference-based memory model.
20 min readR02 · Week 2 Recall & Drill
Week 2 revision: the iterator protocol behind for-loops, argument grammar and closures, data structure Big-O choices, class attribute lookup, and inheritance vs composition.
20 min readR03 · Week 3 Recall & Drill
Week 3 revision: exception discipline and pdb, import resolution and packaging, pytest fixtures and the TDD loop, type hints that no runtime enforces, and Big-O as a growth rate.
20 min readR04 · Week 4 Recall & Drill
Week 4 revision: discrete math as the language under SQL, vectors and cosine similarity, matrices as transformations, the chain rule, and gradient descent from scratch.
20 min readR05 · Week 5 Recall & Drill
Week 5 revision: distributions and Bayes' rule, what a p-value actually claims, two-pointer and sliding-window templates, hashmap internals, and linked-list surgeries.
20 min readR06 · Week 6 Recall & Drill
Week 6 revision: LIFO vs FIFO as a scheduling choice, recursion's three ingredients, tree traversal orders, heaps as partial order, and graph traversal with weights.
20 min readR07 · Week 7 Recall & Drill
Week 7 revision: sort trade-offs beyond Big-O, the two binary search templates, DP preconditions versus caching, greedy proofs and backtracking pruning, and normalisation to 3NF.
20 min readR08 · Week 8 Recall & Drill
Week 8 revision: SQL logical execution order, joins as filtered Cartesian products, aggregate NULL semantics, windows that preserve rows, and recursive CTEs.
20 min readR09 · Week 9 Recall & Drill
Week 9 revision: B-tree selectivity and composite index order, isolation levels and write skew, reading execution plans, the four NoSQL families, and star schema grain.
20 min readR10 · Week 10 Recall & Drill
Week 10 revision: bounded versus unbounded data, Spark stages and shuffles, Kafka as a log rather than a queue, watermarks and exactly-once effect, and idempotent orchestration.
20 min readR11 · Week 11 Recall & Drill
Week 11 revision: dbt as a compiler not an engine, lakehouse metadata layers over Parquet, the four data-quality pillars, lineage-driven governance and cost, and HTTP caching.
20 min readR12 · Week 12 Recall & Drill
Week 12 revision: resource modelling and idempotency keys, GraphQL's N+1 and cost limits, Protobuf field tags and RPC shapes, delegated authorisation versus identity, and Linux processes, memory, and file descriptors.
20 min readR13 · Week 13 Recall & Drill
Week 13 revision: TCP as a byte stream, L4 versus L7 load balancing, cache-aside and stampedes, CDN cache keys and Vary, and Docker layers as processes not VMs.
20 min readR14 · Week 14 Recall & Drill
Week 14 revision: declarative reconciliation over imperative starts, config and secrets injection, cloud identity and network isolation, Terraform state as authoritative mapping, and CAP versus PACELC.
20 min readR15 · Week 15 Recall & Drill
Week 15 revision: replication topologies and split-brain, consistency guarantees and their scope, Raft's real difficulty, hot partitions and consistent hashing, and at-least-once queues.
20 min readR16 · Week 16 Recall & Drill
Week 16 revision: RTO and RPO driving topology, which observability pillar answers which question, PromQL and cardinality, error budgets as budgets, and mitigate-before-diagnose.
20 min readR17 · Week 17 Recall & Drill
Week 17 revision: resource authorization, password KDFs, certificate trust and SAN checks, SQL injection boundaries, leakage-safe evaluation and least-squares gradients.
40 min readR18 · Week 18 Recall & Drill
Week 18 revision: likelihood and decision costs, ridge/lasso geometry, learning-curve assumptions, greedy tree impurity and measured ensemble diversity.
40 min readR19 · Week 19 Recall & Drill
Week 19 revision: negative-gradient boosting, tie-aware ranking metrics, leakage-free preprocessing, imbalance policies and honest evaluation of selected procedures.
40 min readR20 · Week 20 Recall & Drill
Week 20 revision: affine collapse and nonlinear XOR, batched MLP shapes, numerical backprop checks, optimizer recurrences and PyTorch mode/gradient contracts.
40 min readR21 · Week 21 Recall & Drill
Week 21 revision: dropout and normalization contracts, convolution shapes, recurrent Jacobian products, embedding objectives and controlled transfer-learning decisions.
40 min readR22 · Week 22 Recall & Drill
Week 22 revision: exact toy BPE, attention variance and tensor shapes, permutation equivariance, positional mechanisms and fixed-width versus KV-cache budgets.
40 min readR23 · Week 23 Recall & Drill
Week 23 revision: transformer block contracts, attention visibility, normalized decoding filters, conditional compute heuristics and exact streamed attention.
40 min readR24 · Week 24 Recall & Drill
Week 24 revision: prompting evaluation, chunk-span recovery, authorized hybrid ranking, exact-neighbor recall and bounded verified tool-workflow models.
40 min readR25 · Week 25 Recall & Drill
Worked revision of agent handoffs, judge bias, LoRA, KV-cache sizing, batching and multimodal extraction with bounded local code and source-backed answers.
38 min readR26 · Week 26 Recall & Drill
Worked system-design revision: explicit capacity assumptions, atomic identifier allocation, lost acknowledgements, feed work and enforced AI cost budgets.
38 min readDev Environment — Linux/WSL, Terminal, VS Code
The 90 minutes that saves you 90 hours. Real environment, real editor, real terminal — no ‘works on my machine’ for the next six months.
22 min readGit & GitHub — Commits, Branches, PRs
The 90 minutes that turns Git from a scary black box into a save-point machine you trust with your career. Real commits, real branches, real PRs — the muscle memory every senior engineer runs on.
26 min readThe Command Line — bash, pipes, grep, jq
Live in the terminal without fear. The pipes, filters, and text-crunching muscle memory that separates an engineer from a button-clicker — and the 20 commands you'll use every single day for the rest of your career.
24 min readReading Docs & Effective Googling — the Meta-Skill
The single skill that separates a 10× engineer from a 1× engineer: knowing how to find the answer, fast, without asking a human. Man pages, official docs, GitHub source-diving, and search queries that actually work.
24 min readPython Variables & Types — Mental Model of Memory
Not ‘what is a variable’ — the actual model of what happens in memory when you write `x = [1, 2, 3]`. References, mutability, boxes, arrows. The mental picture every senior Python dev has that every junior doesn't.
22 min readControl Flow — if/else, loops, comprehensions
The three shapes of Python control flow every dev needs to reach for on reflex — branches, loops, comprehensions — with the rules for when each one is right and when it silently becomes unreadable.
26 min readFunctions — arguments, scope, closures
Functions are the atom of Python. This session covers the four kinds of arguments, the LEGB scope rule, closures, decorators as functions, and the classic tricks that trip up devs who thought they knew Python.
24 min readData Structures — list, tuple, dict, set (when to use what)
The one-page decision matrix that separates senior Python devs from the rest: given a data shape and a query pattern, know within 5 seconds which built-in structure to reach for — and its Big-O cost.
25 min readClasses & Objects — the OOP Mental Model
Classes in Python are not what they are in Java. Everything is public, `self` is explicit, dunder methods are the interface. This session installs the mental model of what a class actually IS in Python — plus the three patterns you'll use daily.
25 min readInheritance, Composition & Polymorphism
The single most-abused feature in OOP is inheritance. This session teaches the ‘composition first’ rule every senior codebase uses, plus the MRO, super() rules, ABCs, protocols, and how Python's duck typing makes half of Java's ceremony unnecessary.
26 min readErrors, Exceptions & Debugging with pdb
The mindset shift that turns ‘print statement warrior’ into ‘engineer who kills bugs in minutes’. Try/except done right, custom exceptions, tracebacks decoded, pdb keystrokes memorised, and the modern replacements (icecream, ipdb, structlog).
27 min readModules, Packages, Virtualenvs, pip & uv
How Python code is organised, versioned, and shipped — from a single script to an installable package, with reproducible envs on every machine.
25 min readTesting with pytest — TDD Workflow
Turn code from hope into evidence: real pytest patterns — parametrize, fixtures, mocks, coverage — plus the TDD loop that makes refactoring safe.
24 min readType Hints, mypy, dataclasses & pydantic
Modern Python that scales past 1000 lines: gradual typing with mypy, immutable value objects with dataclasses, and runtime-validated boundaries with pydantic v2.
25 min readBig-O Notation — Reasoning About Scale
How to talk about performance without measuring: growth rates, worst/avg/amortised cost, and the constant-factor traps that make theory disagree with reality.
24 min readDiscrete Math — Sets, Logic, Combinatorics, Graphs
The vocabulary of computer science: sets, boolean logic, counting arguments, and graph theory — the four discrete-math tools you'll use in every subsequent session.
28 min readLinear Algebra I — Vectors, Dot Product, Geometry
The language ML speaks: vectors as arrows and lists of numbers, the dot product as similarity, norms as length, and cosine similarity as ‘how alike?’
25 min readLinear Algebra II — Matrices, Transforms, Eigenvalues
Matrices as linear transformations, matrix multiplication as function composition, and eigenvalues as the axes a transform respects — the shape of every neural net.
28 min readCalculus I — Derivatives & Chain Rule
Rate of change is the heart of learning: the derivative as slope, symbolic vs numeric differentiation, and the chain rule that powers every neural net.
26 min readCalculus II — Gradients & Gradient Descent from Scratch
The one algorithm behind all of ML: gradients as the ‘uphill direction’ in n dimensions, SGD as the workhorse, and the learning-rate/momentum knobs that decide whether you converge or explode.
27 min readProbability — Random Variables, Distributions, Expectation
Uncertainty, quantified: random variables, the distributions you'll actually meet (Bernoulli, binomial, normal, exponential, Poisson), expectation, variance, and Bayes' rule.
27 min readStatistics — CLT, Hypothesis Testing, Confidence Intervals
The three ideas that let you turn noisy data into defensible claims: the Central Limit Theorem, p-values, and confidence intervals — with the mistakes that get careers cancelled.
27 min readArrays & Strings — Indexing, Slicing, Two-Pointer
The two data structures every algorithm question secretly starts from — and the two-pointer template that solves half of them in O(n).
26 min readHashmaps & Sets — Hash Functions, Collisions
The single data structure that turns O(n) loops into O(1) lookups — how it actually works under the hood, why it can go pathologically slow, and the design review patterns you must own.
25 min readLinked Lists — Singly, Doubly, When They Win
The data structure reviewers still love — plus the three real-world situations where a linked list actually beats an array.
25 min readStacks & Queues — LIFO/FIFO in Practice
The two most important restricted data structures — and how they secretly power your function calls, browser history, printer queues, BFS, and every parser you've ever used.
25 min readRecursion — Call Stack, Base Case, Worked Examples
The mental model for solving problems by solving smaller versions of themselves — plus the tricks (memoisation, tail-form, iterative rewrites) that make it survive production.
25 min readTrees & BSTs — Traversal (BFS/DFS)
Trees are the recursive data structure that models everything hierarchical — DOM, filesystems, syntax, dependency graphs. Master traversal and balancing here, and every future algorithm gets easier.
26 min readHeaps & Priority Queues
The data structure behind top-K, Dijkstra, event schedulers, and every job runner — how heapq works, when to use it, and the classic patterns that come up in serious production work.
26 min readGraphs — Representation, BFS, DFS, Shortest Path
The most general data structure — and the algorithms that turn ‘find the shortest / cheapest / connected’ problems into 20-line functions.
27 min readSorting — Merge, Quick, and When to Trust the Built-in
The three sorts everyone should know (merge, quick, heap), why Python's sorted() beats them all, and the practice problems that ask you to implement them anyway.
27 min readBinary Search — the Pattern Behind 100 Problems
Sorted (or monotonic) + halving = O(log n). One template, three shapes: classic search, lower/upper bound, and binary-search-on-the-answer. The pattern behind git bisect, B-tree lookups, ship-in-D-days, and half the LeetCode medium set.
27 min readDynamic Programming — Memoisation & Tabulation
Break the problem down, cache the answer. Overlapping subproblems + optimal substructure = polynomial time from exponential recursion. Two dialects (top-down memo, bottom-up tabulation), one recipe (state → transition → base case → order), and the classic classics: Fibonacci, climbing stairs, coin change, LIS, edit distance.
28 min readGreedy & Backtracking — When to Use Each
Two decision-making patterns that live either side of DP. Greedy: bet on the best local move and never look back — fast, occasionally wrong. Backtracking: explore every option and undo dead ends — slow, always right. Learn to prove greedy is safe, prune backtracking aggressively, and pick the right tool in 30 seconds.
27 min readThe Relational Model — Tables, Keys, Normalisation
Design keys, dependencies and historical facts; normalise worked schemas and test real SQLite constraints.
18 min readSQL Basics — SELECT, WHERE, ORDER BY, LIMIT
Query rows safely with explicit NULL, alias, ordering and pagination semantics, verified against exact SQLite results.
16 min readJoins — INNER, LEFT, RIGHT, FULL, Anti-Join
Choose join semantics, preserve measure grain and compare physical algorithms without fan-out or NULL mistakes.
17 min readAggregations — GROUP BY, HAVING, Subqueries
Compute honest grouped metrics, exact medians and weighted rollups; distinguish missing populations and approximation contracts.
16 min readWindow Functions — the Game-Changer
Rank deterministically, reason about peers and frames, and compute calendar-aware deltas and session boundaries.
17 min readCTEs & Recursive Queries
Compose named SQL stages and safely traverse graphs with explicit cycle, reachability and truncation semantics.
17 min readIndexes — B-Tree Intuition, When to Add
Design and validate query-driven indexes; distinguish access paths, output work, visibility and concurrent-build safety.
16 min readTransactions & ACID — Isolation Levels, MVCC
Protect transaction invariants with precise isolation, retry and durability contracts; test local rollback and bounded anomaly models.
18 min readQuery Planning — EXPLAIN, Execution Plans, Tuning
A query returning ten rows can still scan millions, build a large hash table, or repeat a cheap lookup thousands of times. An index is one possible remedy, not a diagnosis. The objective is to read PostgreSQL 16 plans, distinguish
20 min readNoSQL Landscape — KV, Document, Column, Graph
“NoSQL” is an umbrella, not a transaction or performance contract. Key-value, document, wide-column and graph describe different ways to organize access; products often span families. The goal is to explain all four, model Cassand
20 min readData Modelling — Dimensional, Data Vault, OBT
A warehouse needs an agreed meaning for one row before it needs a fashionable schema. This lesson designs a sales star, distinguishes Kimball, Inmon, Data Vault and one-big-table (OBT) approaches, implements historical customer at
20 min readBatch vs Streaming — Mental Model & Use Cases
“Real time” is a requirement to quantify, not an engine to buy. The goal is to classify workloads by input boundedness, freshness and repair semantics, then justify batch, micro-batch or record-at-a-time processing with explicit a
20 min readSpark — RDD, DataFrame, Jobs/Stages/Shuffles
Spark tuning begins with an execution model, not “add executors.” This lesson traces DataFrame expressions through logical/physical plans, jobs, stages, tasks and exchanges, then reasons about skew, broadcast, caching and small fi
20 min readKafka — Topics, Partitions, Consumer Groups
Kafka is a partitioned retained log with independent readers. Treating offset commits as deletion, replication as invulnerability, or a transaction flag as protection for every downstream effect causes design errors. This lesson t
20 min readStream Processing — Watermarks, Windows, Exactly-Once
A loop reading Kafka is not yet a correct stateful processor. This lesson defines time, window membership, progress, emission, state cleanup and sink effects separately. It targets **Spark 3.5.7** and **Flink 1.18** where their co
20 min readOrchestration — Airflow, DAGs, Retries, Backfills
Orchestration coordinates dependencies, scheduling, retries and historical runs. It does not make arbitrary writes atomic or correct. This lesson targets **Airflow 2.10.5** and preserves the full daily-order pipeline, sensor, retr
20 min readdbt — Models, Tests, Docs, Warehouse-Native ELT
Structure staging, intermediate and mart models with explicit grain; Use ref, source, macros and generic/singular test contracts; Choose materialisations and reconcile late changes, updates and deletes.
20 min readLakehouse — Delta / Iceberg / Hudi, ACID on Files
Explain atomic snapshot membership and validated commit retries; Trace Delta versions and distinguish compaction from retention; Compare Delta, Iceberg and Hudi compatibility and maintenance.
20 min readData Quality — Freshness, Volume, Schema, Distribution
Check eligible freshness, volume, schema, validity and distribution; Distinguish unknown checks from passing data and route by consequence; Design consumer-specific publication gates and seasonal baselines.
20 min readGovernance & Cost — Lineage, PII, Attribution
Trace column dependencies and enforce classification separately; Reconcile direct, shared and unallocated cost against a declared total; Design justified retention and verifiable authorised erasure workflows.
20 min readHTTP Fundamentals — Verbs, Status Codes, Headers, Caching
Interpret HTTP messages, methods and conditional response semantics; Separate cache freshness, validation, Vary and private data policies; Explain protocol versions, session state and bounded retry contracts.
20 min readREST API Design — Resources, Versioning, Idempotency
Design resources, domain actions, errors and compatible evolution; Implement atomic operation replay and bounded total-order pagination; Describe OpenAPI, correct deprecation dates and patch semantics.
20 min readGraphQL — Schema, Resolvers, N+1, When to Pick It
Trace typed GraphQL execution, nullability and mutation ordering; Compare exact naive and batched lookup results with scoped authorisation; Bound queries and distinguish persisted documents from allowlists.
20 min readgRPC & Protobuf — When RPC Wins
Define RPC messages and four streaming shapes with explicit limits; Verify Protobuf bytes, presence and mixed-schema compatibility; Distinguish message framing, deadlines, cancellation and durable effects.
20 min readAuthN & AuthZ — OAuth 2.0, OIDC, JWT
Token validation is more than decoding. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
20 min readOS Basics — Processes, Threads, Memory, FDs
Processes, threads and resource accounting. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
18 min readNetworking I — TCP/IP, DNS, Sockets
A reliable byte stream is not a durable message protocol. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
18 min readNetworking II — Load Balancers L4 vs L7, Reverse Proxies
Balance work, drain connections and bound retries. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
17 min readCaching — Cache-Aside, Write-Through, TTLs, Invalidation
Cache-aside races and lease ownership. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
18 min readCDN — Edge, Cache Hierarchies, Cache-Control
Cache keys are isolation boundaries. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
20 min readDocker — Images, Layers, Dockerfile, Networking
Understand container images, cache invalidation, runtime isolation and service networking through a multi-stage Python reference design and measured acceptance criteria.
29 min readKubernetes I — Pods, Deployments, Services
Kubernetes without the mysticism — Pods run containers, Deployments keep N of them alive, Services give them a stable IP. Reason through and optionally deploy a local app, with selectors, probes and rollout failure analysis.
23 min readKubernetes II — ConfigMaps, Secrets, HPA, Network Policies
Connect configuration, secret rotation, autoscaling and network isolation to a complete reference workload, then reason through controller and recovery failures.
38 min readAzure Cloud — Identity, Storage, Networking, App Service
The four pillars of every real Azure workload — Entra ID + RBAC, Storage & Cosmos, VNets & Private Endpoints, App Service & Container Apps. What to pick and why.
28 min readInfrastructure as Code — Terraform / Bicep Basics
Build a versioned Azure Terraform module on paper, understand state and dependency graphs, and rehearse plan review, drift, import, refactoring and recovery without cloud writes.
37 min readCAP & PACELC — the Actual Trade-Offs
Reason from operation histories to CAP and PACELC, compare configured database contracts, and choose consistency for checkout.
20 min readReplication — Leader/Follower, Multi-Leader, Leaderless
Compare replication topologies, acknowledgment boundaries and lag; reason about quorum limits, session positions and fenced failover.
19 min readConsistency Models — Linearizable, Sequential, Eventual
Test consistency with precise operation histories, independent session guarantees and bounded Python checks; choose contracts by invariant.
20 min readConsensus — Paxos & Raft Intuition
Quorum intersection is necessary but protocol rules carry the value. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
18 min readSharding & Partitioning Strategies
Choose hash, range or directory routing, measure movement and hot keys, and plan a versioned snapshot/stream migration with safe cutover.
19 min readMessage Queues — SQS, RabbitMQ, Kafka as Queue
Separate delivery attempts from business effects; compare queue/log contracts, budget retries and build a bounded idempotent-consumer model.
19 min readMulti-Region — Active-Passive, Active-Active, Failover
Match regional data authority, spare capacity and DNS recovery to RTO/RPO objectives; work through loss, fencing and failback examples.
18 min readThe 3 Pillars — Metrics, Logs, Traces
Signals answer questions only if context survives. A source-bounded lesson with worked reasoning, failure analysis and explicit runtime limitations.
20 min readPrometheus, Grafana, OpenTelemetry — Hands-on
Follow telemetry from instrumentation to queries and decisions: versioned stack wiring, weighted ratios, histogram semantics, dashboards and alert failure modes.
20 min readSLIs, SLOs & Error Budgets — the SRE Math
Define reliability in the right units, derive error budgets and burn rates, and test rolling-window alerts without confusing requests with downtime.
20 min readIncident Response — Runbooks, Postmortems, On-Call
Coordinate technical response and communications, choose safe mitigations, verify full recovery and turn evidence into accountable learning.
20 min readAuthN vs AuthZ, Sessions & Password Storage
Separate credential validation from permission decisions; reason about password storage, sessions, JWTs, revocation, tenant isolation and safe local tests.
20 min readTLS 1.3, PKI & Cert Lifecycle
Trace TLS 1.3 authentication and key agreement, inspect PKI trust boundaries, and operate certificate lifecycles without disabling verification.
21 min readOWASP Top 10, Secrets Mgmt & Threat Modelling
Use the OWASP Top 10:2021 as a bounded risk map, then test interpreter and access boundaries and design secrets, STRIDE and dependency controls.
21 min readThe ML Mental Model — Features, Labels, Train/Val/Test
Design an honest supervised-learning experiment, diagnose five leakage mechanisms, compare losses and metrics, and test a small regression pipeline without downloads.
24 min readLinear Regression from Scratch: Solvers, Geometry and Evidence
Derive least squares, test gradients and projection geometry, recover its history, and compare stable and iterative solvers.
20 min readLogistic Regression — Sigmoid, Cross-Entropy, from Scratch
Derive linear log-odds, stable binary cross-entropy and its gradient; separate calibration, ranking and validation-selected decisions.
15 min readRegularization — L1, L2, Elastic Net
Derive ridge, lasso and elastic net; verify normalization, soft thresholding, fold-safe tuning and the AdamW distinction.
15 min readBias–Variance Trade-off & Learning Curves
Derive squared-error bias, variance and noise; measure independent refits and bootstrap limits, and interpret learning curves carefully.
16 min readDecision Trees — Gini, Entropy, Splits
Calculate weighted impurity gains, implement a greedy tree, trace predictions and diagnose leaf-size, pruning and representation limits.
16 min readRandom Forest & Bagging
Build a per-split randomized forest, derive bootstrap coverage and covariance limits, and audit out-of-bag evaluation and feature importance.
16 min readGradient Boosting — XGBoost, LightGBM
Derive gradient and regularized Newton tree updates; run bounded XGBoost and LightGBM experiments with validation-controlled stages.
16 min readEvaluation Metrics — P/R/F1/ROC/PR/AUC
Derive confusion-matrix, ROC and average-precision metrics; select thresholds without test leakage and account for prevalence and capacity.
16 min readFeature Engineering — Encoding, Scaling, Missing
Build a fold-safe heterogeneous feature pipeline; test encoding, missingness, learned state, target cross-fitting and persistence boundaries.
19 min readImbalanced Data — SMOTE, Class Weights, Thresholds
Separate ranking, calibration and threshold decisions under imbalance. Apply weighted learning and fold-local resampling without leakage.
15 min readModel Selection — CV, Hyperparameter Tuning, Optuna
Choose split units and time boundaries that match deployment. Distinguish nested evaluation from hyperparameter selection.
15 min readPerceptron & Activation Functions
Derive perceptron updates and the XOR impossibility proof. Compare activation derivatives and failure modes.
15 min readMulti-Layer Perceptron — Forward Pass
Trace forward-pass shapes and count every parameter. Explain initialization and approximation assumptions.
15 min readBackpropagation — Derived by Hand on a 2-Layer Net
Derive affine and activation gradients including biases. Check complete NumPy gradients against numerical and autograd references.
15 min readOptimizers — SGD, Momentum, Adam, RMSprop
Implement and compare SGD, momentum, RMSprop and Adam updates. Derive startup correction and decoupled weight decay.
15 min readPyTorch Fundamentals — Tensors, Autograd, nn.Module
Use tensor storage, dtype, device and gradient contracts. Build registered modules and a validation-safe training loop.
15 min readRegularization in DL — Dropout, BatchNorm, Weight Decay
Derive dropout moments and distinguish normalization axes. Explain coupled versus decoupled decay and train-eval state.
15 min readCNNs — Convolution, Pooling, ImageNet Architectures
CNNs — Convolution, Pooling, ImageNet Architectures: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readRNNs & LSTMs — Sequences & the Vanishing Gradient
RNNs & LSTMs — Sequences & the Vanishing Gradient: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readEmbeddings — word2vec, GloVe, Contrastive Learning
Embeddings — word2vec, GloVe, Contrastive Learning: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readTransfer Learning & Fine-Tuning Classical DL
Transfer Learning & Fine-Tuning Classical DL: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readTokenization — BPE, WordPiece, SentencePiece
Tokenization — BPE, WordPiece, SentencePiece: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readAttention Intuition — Sequence Bottlenecks and Soft Retrieval
Attention Intuition — Sequence Bottlenecks and Soft Retrieval: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readQ/K/V Math — Scaled Dot-Product Attention Derived
Q/K/V Math — Scaled Dot-Product Attention Derived: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readMulti-Head Attention — Parallel Views
Multi-Head Attention — Parallel Views: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
45 min readPositional Encoding — Sinusoidal, Learned, RoPE
Prove attention equivariance, derive sinusoidal and rotary position geometry, and test offsets without confusing computable positions with length generalization.
20 min readFull Transformer Architecture — Encoder + Decoder
Assemble causal and encoder-decoder Transformers, derive residual and normalization behavior, count parameters, and train a tiny CPU character fixture.
20 min readEncoder (BERT), Decoder (GPT), Enc-Dec (T5) — When Each
Separate Transformer families, pretraining losses and output heads; work through BERT corruption and T5 sentinels and inspect local-only inference interfaces.
20 min readLLM Sampling — Greedy, Beam, Top-k, Top-p, Temperature
Derive temperature, nucleus truncation and search; implement edge-case-safe CPU sampling and translate policies into versioned API contracts.
20 min readScaling Laws — Chinchilla, Compute-Optimal Training
Derive budget-conserving language-model allocations, reconcile Chinchilla and Kaplan, and compare training-only and lifetime-cost objectives.
20 min readEfficient Attention — Flash, Sparse, Linear
Derive online softmax, distinguish exact execution from sparse and kernel operators, and verify CPU parity while specifying a separate GPU-backend proof.
20 min readPrompting — Zero-Shot, Few-Shot, Chain-of-Thought, ReAct
Design testable prompts, bounded tool controllers and evaluation contracts; distinguish published reasoning results from offline fixtures and generated explanations.
20 min readRAG I — Chunking Strategies & Indexing
Build a versioned RAG index with source ranges, tokenizer budgets, stale-chunk removal and access controls; test a complete local lexical-index lifecycle.
20 min readRAG II — Retrieval, Hybrid Search, Reranking
RAG II — Retrieval, Hybrid Search, Reranking: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readVector Databases — pgvector, HNSW, IVF
Vector Databases — pgvector, HNSW, IVF: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readLLM Agents — Function Calling, Tools, Planning
LLM Agents — Function Calling, Tools, Planning: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readMulti-Agent Orchestration — LangGraph, CrewAI Patterns
Multi-Agent Orchestration — LangGraph, CrewAI Patterns: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readLLM Evaluation — LLM-as-Judge, RAGAS, Golden Sets
LLM Evaluation — LLM-as-Judge, RAGAS, Golden Sets: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readFine-Tuning — LoRA, QLoRA, PEFT, When NOT to Fine-Tune
Fine-Tuning — LoRA, QLoRA, PEFT, When NOT to Fine-Tune: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readLLM Serving — KV Cache, Batching, Speculative Decoding
LLM Serving — KV Cache, Batching, Speculative Decoding: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readMultimodal LLMs — CLIP, VLMs, Audio, Video
Multimodal LLMs — CLIP, VLMs, Audio, Video: mechanisms, worked examples, assumptions and source-backed corrections with explicit experiment boundaries.
18 min readSystem Design Framework — Reqs, Capacity, HLD, Deep-Dive
A worked design-review method grounded in measurable requirements, consistent capacity arithmetic, complete request paths and defensible failure tradeoffs.
21 min readDesign a URL Shortener — the Classic Warm-Up
Design a shortener around authoritative mappings, unique allocation, explicit redirect caching and takedown policies, with executable failure models.
23 min readDesign a Chat System — WebSockets, Delivery, Presence
Design idempotent durable chat acceptance, ordering, replay and receipts. Mechanisms, worked examples, failure analysis and complete practice answers.
18 min readDesign a Newsfeed / Recommender — Pull vs Push, Ranking
Derive push and pull costs from follower and reader activity. Mechanisms, worked examples, failure analysis and complete practice answers.
17 min readDesign an AI Chat Product — RAG + Agents + Serving
Design durable turn state, authorized retrieval and tool execution. Mechanisms, worked examples, failure analysis and complete practice answers.
19 min readArrays, shapes, and the first linear model
Master array ownership and axes, then audit attention, context and quantization claims with exact CPU checks.
33 min readVectors, Matrices, and the Geometry of Data
Derive geometry, matrix products, SVD and retrieval scores while testing the limits of each analogy.
18 min readBroadcasting — The Rule That Runs the World
Predict shape sharing, memory costs and numerical failure cases in NumPy and transformer patterns.
15 min readDerivatives are local measurements; backprop is bookkeeping
Rebuild the chain rule from local sensitivities through scalar autograd, matrix pullbacks and checkpointing.
19 min readProbability, cross-entropy, and stable logits
Derive information measures and stable probability losses, then distinguish modern language and preference objectives.
18 min readOptimization: steps, momentum, AdamW, and honest experiments
Trace optimizer updates and numerical safeguards without mistaking toy convergence for universal model performance.
17 min readOne neuron: logistic regression, stable loss, and its boundary
Train and audit a sigmoid neuron, verify exact framework parity, and prove and repair its XOR limitation.
17 min readActivation Functions — sigmoid, tanh, ReLU, GELU, SwiGLU, xIELU
Derive and test activation functions, full gradient chains, gated parameter budgets and source-corrected xIELU.
17 min readThe Forward Pass: Shapes, XOR and Parameter Counts
Compute an MLP by hand, construct a strict-margin XOR classifier, and distinguish actual architecture counts from universal claims.
20 min readBackprop by Hand: Nine Gradients and a Verified XOR Network
Derive all nine ReLU-network gradients, preserve the tanh XOR experiment, and verify finite differences against CPU PyTorch.
20 min readMLP on MNIST: A Complete Local-Only NumPy Recipe
Load existing local IDX files, implement stable multiclass loss and backpropagation, and separate a synthetic contract from real digit evaluation.
20 min readMicrograd: Build and Test a Scalar Autograd Engine
Implement complete scalar reverse-mode differentiation, shared-edge accumulation, stable cross entropy and a four-point neural network.
20 min readVectorization: Measure Speed, Shapes and Memory
Compare exact scalar and array programs, derive einsum contractions and FLOP counts, and measure performance without promised speedup factors.
20 min readPyTorch Tensors and Autograd: Leaves, VJPs and Safe Updates
Port NumPy mathematics to raw PyTorch tensors and verify gradient accumulation, cotangents, graph lifetime and mutation controls.
20 min readnn.Module: Registration, Composition and Checkpoint Contracts
Structure models with registered parameters and buffers, distinguish eval from no-grad, and verify trusted state/config round-trips.
20 min readDatasets, DataLoaders and Collate: Coverage Before Throughput
Test indexed sampling, ragged collation, worker/rank sharding and local stream resume while treating optional cloud adapters as unexecuted.
20 min readThe Training Loop, Logging, and Reproducibility
Build and verify a resumable training state machine with RNG, sampler, optimizer, scheduler, EMA and safe checkpoints.
16 min readGPU and Mixed Precision
Separate device placement, operation-specific mixed precision, loss scaling and measured performance without numerical myths.
15 min readDebugging — nan, inf, and Overfitting a Single Batch
Diagnose training with exact objective contracts, finite checks, tiny-batch fits, negative controls and profiling.
15 min readDropout and generalization — masks, scaling and controlled experiments
Derive dropout moments, preserve leakage-resistant evaluation, test mask variants and choose regularization by controlled experiments.
19 min readBatch Norm, Layer Norm, and RMSNorm — the normalization tour
Derive normalization axes, affine and buffer contracts, implement BN/LN/RMSNorm and test train/eval and calibration failures.
16 min readWeight Initialization — Xavier, He, and μP
Derive fan and second-moment initialization, test activation and gradient propagation, and understand bounded width-transfer parameterizations.
15 min readSchedulers — Warmup, Cosine, One-Cycle, and WSD
Implement and verify warmup, linear, cosine, one-cycle and WSD clocks, resume behavior and fair schedule comparisons.
17 min readGradient Clipping and Accumulation
Derive weighted accumulation and global clipping, flush unequal tails and distinguish AMP, DDP and activation-checkpointing contracts.
17 min readConvolution: local shared operators, shapes and gradients
Compute original convolution examples and general output shapes Implement multi-channel forward and backward accumulation Compare receptive fields, pooling and modern convolution designs.
20 min readCNN architectures: LeNet, AlexNet, residual learning and modern backbones
Build LeNet-like and ResNet18 models with exact parameter counts Distinguish degradation from vanishing gradients Design fair architecture and local-data comparisons.
20 min readCIFAR-10 training: a complete local pipeline and controlled experiments
Build a complete local CIFAR training and selection pipeline Test normalization, parameter groups and weighted evaluation Diagnose training failures with controlled ablations.
20 min readTransfer learning: frozen features, fine-tuning and buffer discipline
Implement local-checkpoint linear and fine-tuning regimes Freeze parameters and BatchNorm buffers deliberately Compare transfer objectives and source-target assumptions.
20 min readData augmentation: tested mixing, task assumptions and calibration
Implement mixup and clipped-area CutMix with exact targets Compute calibration and soft-target loss controls Choose task-valid augmentation and controlled ablations.
20 min readVision Transformers: patch equivalence, position and attention cost
Prove patch projection output and gradient equivalence Build and test a small complete Vision Transformer Explain position interpolation, parameter counts and quadratic cost.
20 min readWord2Vec: complete skip-gram training, geometry and honest evaluation
Train complete skip-gram negative sampling on bundled text Derive lookup and binary-loss gradients and sampling contracts Query and evaluate embedding geometry without semantic guarantees.
20 min readRNNs from scratch: complete BPTT, character generation and structured recurrence
Implement complete NumPy BPTT and verify every coordinate Train and generate with a complete character RNN locally Distinguish clipping, truncation, gates, attention and affine scans.
20 min readLSTM and GRU — Gates, State and Gradient Paths
An ordinary RNN repeatedly applies a nonlinear state transformation. Its time derivative is a product of **time-varying Jacobians**, not just the recurrent matrix's eigenvalue raised to a power. LSTM introduced a separately carried cell state; the la
20 min readSeq2Seq — A Complete Length-Aware Encoder–Decoder
A sequence-to-sequence model defines a conditional distribution over a target sequence given a source. In the fixed-state recurrent version, an encoder reads the source and passes its final state to an autoregressive decoder. For an LSTM the interfac
20 min readWhy Attention — Query-Dependent Source Access
A fixed-state encoder-decoder must route all source information through its terminal state. Attention retains the sequence of encoder representations and lets each decoder step retrieve a different weighted context. This removes the requirement that
20 min readAttention is a weighted sum with a precise mask
Calculate attention numerically, derive its softmax backward pass, and test causal and permutation properties.
24 min readMulti-Head Attention — Shapes, Specialization and KV Budgets
A single attention head already forms a distribution over many keys; it is not forced to pick exactly one token. Multi-head attention gives several independently parameterized distributions and value projections, then mixes their results. At fixed mo
20 min readPositional Encodings — Sinusoids, Learned Tables and RoPE
Unmasked self-attention with shared tokenwise projections and no position signal is **permutation-equivariant**: permuting input rows permutes output rows. It is not invariant unless an additional permutation-invariant readout removes row order. Thus
20 min readTransformer Blocks — Full Architectures and an Analytic Decoder
Attention mixes information across token positions. A position-wise feed-forward network transforms features with the **same weights at each position**. Normalization sets a branch's input or output scale, and residual addition carries an explicit sk
20 min readnanoGPT Rebuilt — A Complete Tested Decoder
The useful exercise in nanoGPT is tracing a compact decoder-only model end to end: configuration, embeddings, fused QKV attention, pre-norm blocks, final norm, tied output projection, optimizer groups and generation. Its public model/train files are
20 min readTraining a Decoder on Local Text — Tiny Shakespeare Recipe
A small character-level decoder is a useful way to inspect tokenization, shifted targets, causal loss, optimizer state and generation. Tiny Shakespeare is one possible **already-local** corpus, not data bundled or downloaded by this audit. This lesso
20 min readKV caching: correct positions, masks, memory and reuse
Implement and test a complete cached decoder, derive cache memory, and distinguish paging, sharing, compression and eviction.
18 min readRoPE and FlashAttention: relative positions and online softmax
Derive rotary attention and tiled normalization, test CPU parity, and separate positional extension from GPU kernel performance.
18 min readByte-pair encoding: merges, Unicode and artifact contracts
Build and inspect deterministic byte BPE, correct weighted merge traces, preserve Unicode bytes and freeze tokenizer artifacts.
18 min readSentencePiece and unigram: lattices, normalization and compatibility
Derive unigram marginal likelihood and soft EM, test segmentation, and distinguish tokenizer algorithms from toolkit and normalization choices.
17 min readPretraining data: auditable extraction, grouping and token shards
Design a provenance-aware pretraining pipeline with tested filters, grouped splits, boundary-safe windows and validated token shards.
20 min readChinchilla scaling: fit assumptions, budgets and serving cost
Derive compute-constrained allocation, correct the numerical budget, and separate fixed-ratio heuristics from fitted and inference-aware scaling.
15 min readData mixing: sampling, exposure, proxy ablations and curriculum
Implement weighted shard sampling, measure domain exposure, run a complete synthetic ablation and explain DoReMi and token-clock schedules.
16 min readQuality and deduplication: MinHash, LSH and measured decisions
Implement probabilistic near-duplicate retrieval with exact verification, audit learned quality policies and screen contamination with explicit limits.
19 min readArchitecture choices: derive and test a 100M decoder
Implement pre-norm, RMSNorm, RoPE, GQA and SwiGLU; reconcile exact model counts, cache budgets and modern architecture claims.
18 min readDistributed Training Basics — DDP and FSDP
Derive distributed-training memory and communication costs, implement rank-aware reference loops, and distinguish DDP, ZeRO and FSDP2.
17 min readRenting Your First GPU — Runpod / Modal / Vast.ai Walkthrough
Choose GPU resources from measured workloads, compare service lifecycles, and plan safe transfer, monitoring, checkpointing and teardown.
17 min readTraining a 100M model: complete local recipe and budget
Build a local-shard training state machine with exact token budgets, validation, persistence and honest resource-dependent execution limits.
14 min readLoss curves and evaluation: likelihood, tasks and controls
Preserve the exact synthetic decoder experiment while restoring token-weighted metrics, downstream evaluation, uncertainty and contamination audits.
18 min readCheckpointing and resuming: consistent state and durable publication
Implement trusted local restart snapshots, test continuation and failures, and derive retention and distributed recovery boundaries.
15 min readPretraining bugs: hypotheses, counterexamples and tests
Diagnose stalled, nonfinite, drifting or misleading training runs through bounded interventions rather than loss-curve folklore.
14 min readScaling from 100M to 1B — A Mental Model
Calculate compute, memory and elapsed-time ranges across model scales, interpret published receipts, and plan infrastructure from measured constraints.
15 min readSupervised fine-tuning: objective, templates and local recipes
Derive assistant-only supervision, test masks and conditioning gradients, and specify pinned local SFT with template and regression checks.
16 min readInstruction datasets: provenance, normalization and mixtures
Audit exact dataset identities and rights, reconstruct conversation trees, and derive reproducible example and supervised-token sampling weights.
18 min readAdaptation with LoRA: low-rank updates and masked supervision
Derive low-rank adapter gradients, inject and test a complete layer, and audit versioned SFT, merge and variant workflows.
16 min readQLoRA: NF4 storage, gradients and local integration
Derive block-scale memory, implement a CPU NF4 teaching quantizer, and distinguish adapter gradients, paging and merge behavior.
15 min readReward Modeling: Pairwise Likelihood, Data and Failure Modes
Derive preference likelihoods, test reward gradients and pooling, and audit data, calibration and reward hacking.
20 min readRLHF with PPO — Intuition + Minimal Code
Derive PPO clipping and GAE, execute a complete tiny CPU loop, and audit language-model trainer, reward and modern RL workflows.
17 min readDPO — RLHF without the RL
Derive DPO from KL-regularized rewards, test masked log probabilities and gradients, and compare preference objectives and trainer contracts.
16 min readEvaluation and Red-Teaming: Protocols, Uncertainty and Safety
Build reproducible capability, chat, domain and red-team evaluations with correct metrics, overlap analysis and uncertainty.
20 min readKV Cache Deep Dive: Correctness, Memory and Serving Budgets
Test exact cached decoding and grouped-query attention, derive byte budgets, and distinguish paging, precision and eviction.
20 min readQuantization — INT8, INT4, GPTQ, AWQ
Compute quantization error and metadata costs, distinguish compression algorithms and kernels, and design a complete local-artifact benchmark.
17 min readPruning and Distillation: Exact Masks and Correct Token Losses
Implement exact pruning masks and shifted masked distillation, derive temperature gradients, and evaluate compression tradeoffs.
20 min readSpeculative Decoding — Acceptance, Residual Sampling and Cost
Prove speculative sampling, implement bounded greedy and stochastic decoders, and compare proposal families with a measured runtime cost model.
17 min readContinuous Batching: Scheduling, Cache Admission and Capacity
Trace static and continuous batches, enforce cache admission, derive Little’s law and diagnose latency-throughput tradeoffs.
20 min readInside vLLM and TGI: Paging, Versioned Schedulers and Operations
Implement a reference-counted block allocator, inspect pinned vLLM internals, and prepare honest serving and observability recipes.
20 min readDeploying an LLM API: Bounded FastAPI Streaming and Lifecycle
Preserve SSE framing, bound admission, authenticate and clean up streaming requests, and design deployment, retry and usage contracts.
20 min readLatency vs Throughput — Little's Law, TTFT, ITL, and Load Testing
Define honest streaming metrics, derive capacity and test SLO measurement with bounded load-test references.
16 min readMultimodal — CLIP → LLaVA
Derive contrastive learning and visual-token interfaces, train a synthetic dual encoder and design a complete multimodal evaluation.
15 min readAgents and Tool Use
Build a bounded tool controller with validated proposals, independent authorization, recovery and task-level evaluation.
15 min readRAG as a testable evidence pipeline, not a truth switch
Implement chunking, exact retrieval and rank fusion, integrate evidence packing and evaluate a complete RAG pipeline.
18 min readMixture of Experts (MoE) Intuition
Implement sparse expert routing, derive parameter and memory accounting, and test load-balancing and dispatch assumptions.
15 min readLong Context — RoPE Scaling, YaRN, ALiBi
Derive RoPE extension, YaRN scaling and ALiBi, then evaluate long-context systems without confusing acceptance with recall.
15 min readRed-Team + Safety Eval
Design controlled safety tests, separate harm from refusal, and connect system controls to evidence-based release decisions.
15 min readCapstone: a reproducible model-and-evidence laboratory
Complete a reproducible CPU laboratory or a fully specified 100M training and release project with explicit evidence gates.
19 min readShip It — Deploy, Package, Sustain
Choose a route from local Python to an API, from an app to a container, or from a binary to a Windows package—and build a repeatable review and learning habit.
8 min readStanford CS229: Machine Learning Course
A source-reviewed CS229 orientation with worked linear algebra, probability, optimization and runnable algorithm fixtures.
17 min readThe 6-Month Learning Plan · 130 Sessions and a Foundations Lab
A coherent 130-session, 16-module engineering curriculum with 26 revisions, a protected ten-lesson Foundations Lab and honest pacing and prerequisite boundaries.
30 min readMS Stack Ch 22 — Pro skills (the bits no one writes down)
Code review craft, on-call composure, incident writing, technical proposals, mentoring, learning velocity, knowing when to rewrite. The chapter that turns a strong engineer into a senior one.
31 min readMS Stack Ch 21 — Testing strategy
Unit, integration, end-to-end, contract, mutation, load — the testing pyramid for ASP.NET Core + React on Azure. xUnit, WebApplicationFactory, Vitest, Playwright, k6, Stryker, Pact.
30 min readMS Stack Ch 12 — KQL contracts, joins and telemetry
Read KQL pipelines, preserve join and time-window semantics, design bounded telemetry queries, and separate parameter binding, authorization and query cost.
35 min readFrom Novice to Fluent on the Modern Microsoft Web Stack — 22-Chapter Self-Study Plan
An opinionated 22-chapter self-study plan from zero to fluent on the modern Microsoft web stack: PowerShell + .NET + ASP.NET Core + React + TypeScript + Azure + KQL + Polly + Bicep — with worked examples, failure analysis and practice.
9 min readMS Stack Ch 1 — Developer tooling
PowerShell, Git's three trees, VS Code, browser DevTools, and the package managers that run your day. The boring tools that determine whether you'll feel fluent or fighting for the next two years.
29 min readMS Stack Ch 2 — Web fundamentals
HTTP, headers, cookies, TLS, REST, CORS, JSON — the wire-level protocol every backend and frontend bug eventually reduces to. Buy yourself fluency in the protocol and stop guessing.
30 min readMS Stack Ch 3 — C# language
C# 12 + .NET 8: the type system, LINQ, generics, async/await, pattern matching, records, nullable reference types. The language you'll write 1000s of lines of in production.
26 min readMS Stack Ch 4 — .NET runtime and async
The CLR, garbage collector, Task vs ValueTask, the async state machine, cancellation, the dotnet CLI, NuGet, global.json, central package management — the runtime your C# code actually lives in.
27 min readMS Stack Ch 5 — ASP.NET Core
Minimal hosting, dependency injection, middleware, routing, configuration, options, model binding, ProblemDetails, BackgroundService, health checks. The web framework you'll spend the next decade in.
25 min readMS Stack Ch 6 — Modern frontend baseline
Semantic HTML, ARIA + a11y, the CSS cascade + box model + Flexbox + Grid, modern JavaScript (ES2024), fetch, the event loop. The browser-side foundations every React app stands on.
39 min readMS Stack Ch 7 — TypeScript
Structural typing, narrowing, generics, discriminated unions, utility types, tsconfig. TypeScript without the over-engineering.
39 min readMS Stack Ch 8 — Frontend build tooling
Vite, HMR, Rollup, esbuild, npm vs pnpm, tree-shaking, env vars, dev proxy. Understanding what your bundler is actually doing so when it breaks, you know where to look.
36 min readMS Stack Ch 9 — React
Components, JSX, the rendering model, hooks (useState, useEffect, useMemo, useCallback, useRef, useReducer, useContext), custom hooks, error boundaries, Suspense, wrapping imperative libraries. React without the cargo cult.
34 min readMS Stack Ch 10 — Routing and state in SPAs
React Router (nested + lazy), URL as state with useSearchParams, server state vs UI state, TanStack Query, Zustand vs Redux Toolkit. Choose your state strategy deliberately.
26 min readMS Stack Ch 11 — Data visualisation with Highcharts
Highcharts options model, series types, axes, performance for high-cardinality data, theming, accessibility, exporting. A versioned charting model for enterprise dashboards.
28 min readMS Stack Ch 13 — Azure App Service
App Service plans, deployment slots + swap + warmup, app settings, Key Vault references, VNet integration, scale-out rules, custom domains + TLS. The Microsoft PaaS that hosts most of the stack.
27 min readMS Stack Ch 14 — Identity for cloud apps
Entra ID, OAuth 2.0 + OIDC, Easy Auth (App Service Authentication), Managed Identity, On-Behalf-Of flow, certificate-based authentication. The identity stack that lets you stop storing passwords or secrets.
27 min readMS Stack Ch 15 — Observability
Serilog structured logging, Application Insights, OpenTelemetry, correlation IDs, distributed tracing, KQL queries for telemetry, alerts, dashboards. Knowing what your app is doing in production.
22 min readMS Stack Ch 16 — Resilience patterns with Polly v8
Retry with jittered backoff, timeout, circuit breaker, bulkhead, fallback, rate-limiter, hedging — composed into a single resilience pipeline. The patterns that keep your app alive when downstream services don't.
23 min readMS Stack Ch 17 — Caching
IMemoryCache, IDistributedCache, HybridCache (.NET 9), Redis, cache-aside, write-through, stampede protection, invalidation, TTL strategies. Freshness, isolation and load control without invented speed guarantees.
25 min readMS Stack Ch 18 — CI/CD with Azure DevOps
YAML pipelines, templates + parameters + extends, agent pools, federated identity for Azure deploys, SDL gates (CodeQL, credential scanner, container scanning), multi-stage deploys, environments + approvals.
36 min readMS Stack Ch 19 — IaC and rollout orchestration
Bicep modules, what-if previews, environments, region rollouts. Awareness of Ev2 (Microsoft internal), Spinnaker, ArgoCD. The pattern for safely deploying infrastructure + apps across regions.
30 min readMS Stack Ch 20 — Security baseline
OWASP Top 10, secrets management, transport security, auth hardening, supply-chain integrity, input validation, output encoding, security headers. The non-negotiable security checklist for every web app.
24 min readAutomating audio generation
From text , generate audio files and publishing them to webapp
13 min readDeploying scripts as an API in Azure
Deploying local python scripts and converting them as an API.
9 min readBuilding windows app and publishing to app store.
Exploring the fundamentals of building an .exe file from scratch, including C++ compilation, object files, linking, DLLs, and more.
10 min readBasics of Azure AI Foundry
A self-sufficient guide to Azure AI Foundry — what it is, how the hub/project/deployment model works, how to ship a grounded agent end-to-end with SDK + Bicep, and the security/eval/cost levers you cannot skip.
12 min readTaking the Azure Fabric Ignite Edition Challenges to Complete
Microsoft Learn Challenge conducting a challenge to get good in few of the challenges which are super useful to complete to gain knowledge on Microsoft Fabric.
23 min readExploring different services in GCP
Exploration and documentation of different services offered in GCP
22 min readStarting a company in India — a planning journal, corrected
Tech Vistara's recorded domain and landing-page work, with a source-checked comparison of entity structures, incorporation, tax, recognition, IP and operating controls. Proposed steps remain proposed.
26 min readExploring Azure Data Explorer and Best Practices
A self-sufficient deep-dive on Azure Data Explorer (ADX/Kusto) — architecture, the KQL language from zero to advanced, ingestion patterns, performance/cost levers, and operational best practices.
16 min readAI Voice chatting to help with Customer support use-cases
Using current speech augmented LLMs (SpeechLLMs) with realtime voice modality to understand user issues and to provide support and solutions.
5 min readAudio to Video Generation Using Replit AI and Deploy as an Azure Webapp
Tool to convert an uploaded audio mixed with an image and generate a video format with image and uploaded audio in the video format.
5 min readDeploying Web Applications in Azure with Docker
A self-sufficient, production-minded walkthrough — from Docker internals to a hardened deploy on Azure App Service / Container Apps.
16 min readOrchestrating ML Pipelines with Azure Data Factory
Leveraging Azure Data Factory for Scalable and Efficient Machine Learning Workflows
10 min readDeveloping a Astrology webapp version 1.
Initial version 1 of Astro app hosted at astroyuga.com
5 min readImproving the UI of this blogging app - V2
Changing the UI layout and improving the experience by modernizing the UI with custom styling
6 min readLeveraging CURSOR and Azure Services for Rapid Web Deployment
Accelerating Development and Deployment Cycles with AI Tools
7 min read