Notes on AI, ML, data & the engineering behind them.

LeetCode — From Basics to Interview-Ready (65 Sessions)

LeetCode is a motor skill, not a knowledge skill. A 65-session pattern-first curriculum: one pattern per session, five problems that are that pattern in disguise, and a spaced queue that makes it stick.

L61 · Mock 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.

L62 · Company-Tagged — Microsoft & Amazon

Work the frequency-ranked lists for the two companies that matter most to you, and adapt to each one's distinct interview style rather than treating all loops as identical.

L63 · Senior-Flavour Coding

The hybrid round where coding meets design: rate limiters, LRU caches, schedulers and consistent hashing — built by composing primitives you already own.

L64 · Contest Simulation

A real timed LeetCode weekly contest — the closest available replica of interview adrenaline, and the only place to practise performing rather than solving.

L65 · Final 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.

L56 · Advanced 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.

L57 · Mock 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.

L58 · Mock Set 2 — Narrated & Recorded

Two unseen Mediums solved entirely out loud, screen and audio recorded, then played back — the fastest available fix for interview communication.

L59 · Blind 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.

L60 · Weak-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.

L51 · Design 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.

L52 · Design 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.

L53 · Sorting & 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.

L54 · Segment 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.

L55 · String Algorithms

KMP's failure function, rolling hashes, and the Z-function — the three ways to avoid re-comparing characters you have already matched.

L46 · Bit 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 interviews.

L47 · Math & 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.

L48 · Intervals

Sort by start, merge on overlap: the four-problem interval family, and why Meeting Rooms II needs a heap on top of the sort.

L49 · Greedy — 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.

L50 · Matrix 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.

L41 · DP 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.

L42 · DP 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.

L43 · DP 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.

L44 · DP 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.

L45 · Tries — 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.

L36 · DP 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.

L37 · DP V — 0/1 Knapsack

The single most reused DP shape in interviews: a set of items, each taken at most once, under a capacity budget. Master the grid and the space-optimised 1D roll, and half of 'hard' DP becomes recognition.

L38 · DP 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.

L39 · DP 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.

L40 · DP 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.

L31 · Backtracking 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.

L32 · Backtracking 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.

L33 · DP 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.

L34 · DP 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.

L35 · DP 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.

L26 · Heaps & 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).

L27 · Graphs 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.

L28 · Graphs 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.

L29 · Graphs 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.

L30 · Graphs 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.

L21 · Recursion & 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.

L22 · Trees 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.

L23 · Trees 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.

L24 · Trees 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.

L25 · Trees 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.

L16 · Stacks — 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.

L17 · Monotonic Stack

Next greater and next smaller element in O(n): keep a stack whose order never breaks, and pop everything the current element resolves.

L18 · Queues & 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.

L19 · Linked 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.

L20 · Linked 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.

L11 · Sliding 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.

L12 · Prefix 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.

L13 · Binary 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.

L14 · Binary 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.

L15 · Binary 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.

L06 · UMPIRE — 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.

L07 · Two 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.

L08 · Two 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.

L09 · Sliding 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.

L10 · Sliding 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.

L01 · The LeetCode Game — How to Read a Problem

Constraints are not decoration. They are the interviewer quietly telling you which complexity class is acceptable, and therefore which algorithm to reach for.

L02 · Big-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.

L03 · Python for Speed — The 20 Idioms That Matter

The small set of standard-library tools that turn a fifteen-line interview solution into a five-line one, and the syntax you must be able to type without thinking.

L04 · Arrays & 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.

L05 · Hashing — 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.

Where LLMs Came From, and What They Actually Are

The 80-year origin story, the five ideas that actually matter, and a verified watch-list to go deeper — no maths required.

Building a Learning System That Actually Sticks

Most self-study fails at retention, not effort. The complete architecture of a 26-week system — 130 concept sessions, 65 LeetCode sessions, spaced revision, and a calendar that enforces retrieval practice instead of re-reading.

Kimi K3 From Zero to Deep — Math, Architecture, Training, and Systems

A zero-to-deep Kimi K3 course: prerequisite math and terminology, Transformers and MoE, KDA, AttnRes, vision, RL, training systems, inference, benchmarks, and a verified YouTube learning path.

How Transformers actually attend

Beyond the textbook diagrams — what a single attention head is really computing, how multi-head splits the world, and why scaling laws keep rewarding bigger context.

Designing a recommendation system from scratch

Retrieval vs ranking, candidate generation, freshness vs relevance — the tradeoffs every real recommender lives by.

Kafka 101 for ML engineers

Topics, partitions, consumer groups — the parts of Kafka that actually matter when you put ML features behind it.

Overall Engineering Clarity — Data, Distributed Systems and AI (Deep Dive)

A long-form, primary study companion. Internals, flows, decision trees, code, and Q&A with reasoning across Spark, lakehouse, graphs, search, LLMs, RAG/agents, distributed HLD, governance, modeling, SQL, JVM, Python, K8s and CI/CD.

Data Infrastructure for AI & Experimentation at Scale

A comprehensive deep-dive into the data backbone powering ML, personalization, experimentation, and GenAI on modern streaming platforms

Automating audio generation

From text , generate audio files and publishing them to webapp

Deploying scripts as an API in Azure

Deploying local python scripts and converting them as an API.

Learning how to build an recommendation system from initial signals

From a few initial adopters of a product, how we can target new set of users who are more likely can use the product

Building 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.

Stanford CS229: Machine Learning Course

CS229 provides a broad introduction to statistical machine learning (at an intermediate / advanced level) and covers supervised learning (generative/discriminative learning, parametric/non-parametric learning, neural networks, support vector machines); unsupervised learning (clustering, dimensionality reduction, kernel methods); learning theory (bias/variance tradeoffs, practical ); and reinforcement learning among other topics

Best LLM Prompt for understanding any concept in-depth

Use this prompt for gathering information all at one place

Introduction to TensorFlow on Google Cloud

Diving deep into a Google Skill boost

Diving deep into Tiktok recommendation engine

Going deeper into the video rec repo Monolith and paper produced by Bytedance

Basics 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.

Reading on MEDICAL ERROR DETECTION AND CORRECTION IN CLINICAL NOTES

This blog explores a paper on detecting and correcting medical errors in clinical notes using Large Language Models (LLMs)

Apache Airflow - open source orchestration engine

Architecture of Apache Airflow, how DAGs help design complex flows and dependencies, and how we can leverage Apache airflow to train a ML Model and monitor.

Taking 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.

Exploring different services in GCP

Exploration and documentation of different services offered in GCP

Starting a company in India

Documenting the process of starting a company in india

Exploring 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.

Google 5 Day Gen AI course with interactive hands-on practice

Google and Kaggle provided good summary course on Gen AI , the blog contains details and highlights of the course.

RAG architecture basics and workings

Retrieval-Augmented Generation from first principles — embeddings, vector databases, chunking, retrieval, prompt construction, evaluation, and common failure modes — enough depth to build one yourself.

AI 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.

Audio 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.

Deploying 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.

Orchestrating ML Pipelines with Azure Data Factory

Leveraging Azure Data Factory for Scalable and Efficient Machine Learning Workflows

Developing a Astrology webapp version 1.

Initial version 1 of Astro app hosted at astroyuga.com

Improving the UI of this blogging app - V2

Changing the UI layout and improving the experience by modernizing the UI with custom styling

Leveraging CURSOR and Azure Services for Rapid Web Deployment

Accelerating Development and Deployment Cycles with AI Tools