Blog
98 posts14 domains20202026
Selected writing
- How Kafka Really Works: Lessons from a 60M+ Events/Day Production Pipeline
Understanding Kafka's core architecture through real production experience at 60M+ events per day.
Backend & Infra
- Protecting PostgreSQL Primaries from Replication Slot Failures
Exporting slot telemetry and building an automated WAL protection control loop for high-throughput CDC pipelines.
Postgres Series
- PostgreSQL Logical Replication at Scale: Database-Side Guardrails for 60M+ Change Events
Configuring replication slots, WAL retention limits, failover strategy, and monitoring to protect the primary under sustained peak load.
Postgres Series
- How to Stop Your NL2SQL Agents From Crashing in Production: The Worker-Pool Pattern
A guide to process boundary isolation, preventing system-wide failures in LLM-driven data applications
AI System Design
- The 70B LLM Optimisation Playbook: From 57.5GB to 24.3GB Per GPU
A step-by-step guide to Weight, KV Cache, and Activation quantization (FP8 & 4-bit) to reclaim VRAM and unlock 2x performance.
AI System Design
- Scaling Contrastive Training: Batch Size, GPU Gathering, and Gradient Caching
Why bigger training batches make embedding models better, and how teams build batches too big for any single GPU to hold
Vector Databases
All posts
98 posts
- Vector Compression and Quantisation: Fitting Billions of Vectors in Memory
A billion 768-dimensional float32 vectors take about 3 terabytes just for the raw numbers.
Vector Databases
- Indexing Deep Dive: IVF and IVF-PQ
HNSW buys speed and recall by keeping a graph, and every vector it touches, resident in RAM — IVF and IVF-PQ are what cluster-based systems reach for when that stops fitting.
Vector Databases
- Indexing Deep Dive: HNSW, Under the Hood
How the multi-layer proximity graph is actually built and searched, and where the real trade-offs live.
Vector Databases
- The Curse of Dimensionality: Why Exact Nearest-Neighbor Search Does Not Scale
As dimensionality increases, it becomes effectively impossible to tell the nearest point in a dataset from the farthest one.
Vector Databases
- Inside the Encoder: Tokens, Attention, and How a Transformer Actually Works
Opening the sealed box: token embeddings, positional encoding, self-attention, multi-head, feedforward, and residuals.
Vector Databases
- Distance Metrics and Similarity Search: Cosine, Euclidean, and Dot Product
Cosine, Euclidean, and dot product are not interchangeable dropdown options — pick the wrong one and every query still returns a confident, quietly wrong ranking.
Vector Databases
- Scaling Contrastive Training: Batch Size, GPU Gathering, and Gradient Caching
Why bigger training batches make embedding models better, and how teams build batches too big for any single GPU to hold
Vector Databases
- How Embedding Models Actually Learn: The Math Behind Contrastive Training
The InfoNCE formula, the pooling code, and the training loop behind every embedding model, worked through with real numbers.
Vector Databases
- Embeddings 101: How Text, Images, and Audio Become Vectors
How embedding models learn to turn text, images, and audio into vectors, explained with everyday analogies and no jargon.
Vector Databases
- What Is a Vector Database? Origins, Use Cases, and How It Differs from Relational and NoSQL Systems
Why nearest-neighbor search needed an entirely new kind of database, not just a new column type.
Vector Databases
- LLM Serving Architectures: Batching, KV-Cache, Multi-Tenancy
Inside the batching, caching, and multi-tenancy decisions that determine your cost per token.
AI System Design
- Orchestration & Memory: Context Management for Long-Running Agents
A system design guide to context windows, memory types, and multi-agent coordination for agents that run for hours or days.
AI System Design
- Agentic Systems: Tool Use, Planning, Multi-Step Reasoning
A system design guide to how agents plan, call tools, and reason across multiple steps in production.
AI System Design
- Fine-Tuning vs. RAG vs. Prompting: Choosing the Right Approach
A practical framework for deciding when to prompt, retrieve, or fine-tune, and how to combine all three.
AI System Design
- Embeddings & Vector Databases: Architecture and Trade-offs
Inside the index: how embedding choices and ANN architecture decide your RAG system's speed, cost, and recall.
Vector Databases
- Designing RAG Systems: Retrieval, Chunking, Re-ranking, Grounding
Chunking, hybrid retrieval, re-ranking, and grounding checks: designing RAG as a pipeline instead of a single embedding lookup
AI System Design
- How AWS Lambda Runs 15 Trillion Invocations a Month: Firecracker, Snapshots, and Tiered Caches
Inside the microVM stack, snapshot restores, and three-tier caches that let one platform run trillions of tenant invocations.
System Design Case Studies
- Pretraining vs. Post-Training: How a Text Predictor Becomes an Assistant
The two-stage training process that turns a raw next-token predictor into a model with a point of view.
J-Space Primer
- Chain-of-Thought and Scratchpad Reasoning: The Model Thinking Out Loud
Why letting a model write out its reasoning improves accuracy, and why that visible channel isn't the whole story.
J-Space Primer
- Attention Mechanism Basics: How Tokens Reach Across the Whole Context
How queries, keys, and values let any token pull information from anywhere earlier in a sequence, no matter how far back.
J-Space Primer
- Procrastinate: Turning Postgres Into Your Task Queue
How PostgreSQL's LISTEN/NOTIFY and SKIP LOCKED quietly replace your message broker, and when they shouldn't.
Postgres Series
- GPT-Live: OpenAI's Full-Duplex Voice Architecture Ends the Turn-Taking Era
Every voice assistant you have used, from Siri to the original ChatGPT Advanced Voice Mode, shares a hidden assumption: conversation…
AI Breakthroughs
- Postgres Learns to Speak Graph: Inside SQL/PGQ and PostgreSQL 19
PostgreSQL 19 ships native graph pattern-matching with SQL/PGQ. Here's how CREATE PROPERTY GRAPH and GRAPH_TABLE work, and how they stack up
Postgres Series
- How WhatsApp Moved 50 Billion Messages a Day With Just 32 Engineers
How 32 engineers ran a global messaging service on Erlang, Mnesia, and FreeBSD, and the ruthless simplicity that made it possible.
System Design Case Studies
- Transformer Layers and the Residual Stream
The shared vector every transformer layer reads from and writes to, and why it's the concrete object interpretability tools actually probe.
J-Space Primer
- Prompt Engineering as a System Design Discipline
Why the next evolution of prompt engineering looks like software architecture, not wordsmithing.
AI System Design
- A Global Workspace in Language Models: Anthropic Finds a Silent "J-Space" Inside Claude
Anthropic's J-lens uncovers a compact internal workspace in Claude that mirrors global workspace theory of consciousness.
AI Breakthroughs
- Why Framing Comes Before Architecture
Latency, cost, and quality are three dials that pull against each other. Good LLM design is choosing where each one sits, on purpose.
AI System Design
- How YouTube Scaled MySQL to 2.49 Billion Users: The Vitess Story
A tour of Vitess, the layer that lets YouTube run 2.49 billion users on plain MySQL, plus the 9 patterns any team can steal from it.
System Design Case Studies
- Why LLM-Era AI Systems Break Every Rule You Learned About ML in Production
The model is just one component. The system is everything around it: context, tools, orchestration, evals, and cost controls.
AI System Design
- PostgreSQL Internals, CDC, Kafka, and Distributed Systems Engineering Series
PostgreSQL WAL, logical replication, Kafka, CDC pipelines, and distributed systems lessons from production-scale systems.
Postgres Series
- Kafka-Based PostgreSQL → Salesforce Architecture (Part 2): How the System Actually Works
Reconciling streaming CDC, batch-oriented APIs, and lakehouse storage in a production-grade PostgreSQL to Salesforce architecture.
Postgres Series
- PostgreSQL to Salesforce at Scale: Evolving a CDC Pipeline with Kafka
From table-based buffering to a distributed log architecture for multi-consumer, high-throughput systems
Postgres Series
- Building a Reliable PostgreSQL → Salesforce CDC Pipeline: Lessons from WAL, Replication, and Failure Isolation
Designing a serverless data pipeline with Azure Functions while protecting PostgreSQL using deterministic control loops
Postgres Series
- Protecting PostgreSQL Primaries from Replication Slot Failures
Exporting slot telemetry and building an automated WAL protection control loop for high-throughput CDC pipelines.
Postgres Series
- PostgreSQL Logical Replication at Scale: Database-Side Guardrails for 60M+ Change Events
Configuring replication slots, WAL retention limits, failover strategy, and monitoring to protect the primary under sustained peak load.
Postgres Series
- PostgreSQL Logical Replication Internals: restart_lsn vs confirmed_flush_lsn Explained
How LSN movement controls WAL retention and disk stability
Postgres Series
- Understanding PostgreSQL Logical Replication: The Complete End-to-End Flow
Understand how PostgreSQL streams row-level changes using WAL, logical decoding, replication slots, and subscriber feedback.
Postgres Series
- From Hot Partitions to Stable Throughput: Lessons From Kafka in Production
What partition skew, consumer lag, and downstream bottlenecks taught me about operating Kafka at scale
Backend & Infra
- How to Choose the Right Messaging System in Distributed Systems
A practical guide to task queues, Log-Based Queues, and Pub/Sub
Backend & Infra
- Partitioning vs. Sharding: A Practical Guide to Scaling Beyond One Machine
Confused by database scaling? Here is a plain-English breakdown of partitioning and sharding, and how they keep your app running fast.
Backend & Infra
- How Kafka Really Works: Lessons from a 60M+ Events/Day Production Pipeline
Understanding Kafka's core architecture through real production experience at 60M+ events per day.
Backend & Infra
- Beyond Accuracy: A Developer's Guide to Reliable LLM Evaluation
Accuracy is a vanity metric. To build production-grade AI, you need to master the tension between Precision, Recall, and the F1 Score
AI System Design
- How to Stop Your NL2SQL Agents From Crashing in Production: The Worker-Pool Pattern
A guide to process boundary isolation, preventing system-wide failures in LLM-driven data applications
AI System Design
- Beyond Schema: Why Your AI Can't Write Good SQL (and How to Fix It)
When we began building the NL2SQL platform, we thought, "If the AI knows the table schemas, it should be able to write good SQL, right?"…
AI System Design
- Engineering Trust: A Defensive Architecture for NL2SQL Systems
The promise of Natural Language to SQL (NL2SQL) is transformative: democratising data access by enabling anyone to query complex databases…
AI System Design
- Scaling Up RL: From Q-Tables to Deep Q-Networks (DQN)
Stop counting states and start approximating them. Here is how DQN scales Reinforcement Learning to the infinite.
LLM Architectures
- From Q-Learning to LLMs: Mastering the Bedrock of Post-Training
Master the basics of Value-Based Learning before diving into complex policy-based methods like PPO and GRPO.
LLM Architectures
- Scalable Inference with RDMA and Tiered KV Caching
How zero-copy networking and memory offloading resolve the GPU memory bottleneck
AI System Design
- The Intuition Behind LoRA & QLoRA: Fine-Tuning LLMs Without Going Broke
Large Language Models (LLMs) have unlocked extraordinary capabilities, but all are trained on general-purpose data. You have to write long…
LLM Architectures
- The 70B LLM Optimisation Playbook: From 57.5GB to 24.3GB Per GPU
A step-by-step guide to Weight, KV Cache, and Activation quantization (FP8 & 4-bit) to reclaim VRAM and unlock 2x performance.
AI System Design
- How to Serve a 70B Model with a 128K Context on Just 8 H100s
Deploying a 70-billion-parameter model with a 128K context limit is a massive infrastructure challenge. A single H100 SXM GPU with 80GB of…
AI System Design
- Decoding Real-Time LLM Inference: A Guide to the Latency vs. Throughput Bottleneck
A deep dive into the engineering bottlenecks (TTFT, batching, and the KV Cache) that define real-time LLM performance.
AI System Design
- The Secret to the First Word: How LLMs Build Context with Prefill
A technical-but-simple guide to how LLMs process your prompt, build the KV Cache, and why it impacts response speed (TTFT)
LLM Architectures
- How LLMs Understand Your Prompt: A Deep Dive into Prefill Attention
Go beyond Q, K, V. Learn how causal masks, parallel heads, and the KV cache work together to process your prompt instantly
LLM Architectures
- From Prompt to Response: Unpacking the Magic of LLM Inference
Learn how Large Language Models (LLMs) work. This guide breaks down LLM inference into two simple phases: the prefill and the decode.
LLM Architectures
- I Learned How Azure Functions Run My Code: A Deep Dive into the Python Worker and gRPC
How Azure Functions runs Python: Inside the out-of-process model, the Python Worker, and its gRPC connection.
Azure Functions Internals
- I Learned How Azure Functions Run My Code: A Deep Dive into the Host and WebJobs SDK
A deep dive into the Azure Functions Host and the WebJobs SDK engine that powers your serverless code.
Azure Functions Internals
- I Spent an Entire Weekend Demystifying the Azure Functions Runtime so that You Can Learn It in 5 Minutes.
Photo by Alexandre Debiève on Unsplash
Azure Functions Internals
- Messy Logging Config? Here's the dictConfig Fix
Learn the intent behind dictConfig: using one clean dictionary to finally take control of your scattered Python logging configuration.
Python Logging
- Python Logging Unveiled: What Happens When You Call .info()?
Ever wonder how Python logging decides what to show? We break down the journey of your log messages from creation to output.
Python Logging
- How to Choose the Right Python Logging Setup: A Breakdown of the 4 Methods
Stop guessing which logging method to use. This guide breaks down the pros and cons of all four options to help you make the right decision
Python Logging
- What Actually Happens When You Use logger.setLevel() in Python?
Demystifying logger.setLevel(): See How Python Instantly Manages Your Log Levels.
Python Logging
- Get Your Python Logs Talking: A Clear Guide to Adapters & Filters
Add powerful context to your Python logs. A straightforward walkthrough of LoggerAdapters and Filters for truly better insights
Python Logging
- Log Like a Pro: Understanding Python's Logging Essentials
Python logging deep dive: Grasp Loggers, Handlers, Filters, & Formatters for insightful, error-free code
Python Logging
- From Data to Vectors: How Vector Databases Revolutionize Data Storage
Master vector databases and how they store text, images, and audio as vectors to enhance search and recommendation systems
Vector Databases
- Discover the Magic Behind Your Searches: How Semantic and Vector Search Transform Your Online Experience
Discover how semantic and vector search technologies combine to deliver accurate, relevant, and efficient online search results.
AI System Design
- Understanding Azure Synapse Link: Initial Sync, Incremental Changes, and In-Place Updates
In the world of data management, where efficiency and accuracy are everything, especially with the massive amounts of information stored in…
Azure & Cloud Fundamentals
- The Mechanics of Query Expansion in RAG Systems: A Theoretical Exploration of PRF and LLM Techniques
Learn How Query Expansion, PRF & LLMs Power RAG Systems for Enhanced Search Accuracy and Relevant Results
AI System Design
- Are You Combining Software Engineering and Data Engineering for Maximum Efficiency?
Optimize Data Engineering with Top Software Engineering Practices: Enhance Code Efficiency, Decoupling, Python SQL & More
Software Engineering
- Rediscovering Query Expansion: The Classic Technique Powering Modern AI Searches
Boost Your Search with Query Expansion, PRF & LLMs: Enhance Accuracy Using Classic Techniques and Modern AI Strategies
AI System Design
- Transitioning from Export to Data Lake to Azure Synapse Link: What You Need to Know?
As businesses increasingly rely on data-driven insights, choosing the right data storage and processing solutions is crucial. For those…
Azure & Cloud Fundamentals
- Optimizing Data Synchronization for Downstream Systems in Azure Synapse Link
Keeping your source and downstream systems in sync is key to maintaining data accuracy and smooth operations. When using Azure Synapse…
Azure & Cloud Fundamentals
- How Switching to Azure Synapse Link Delivers Cost Savings and Enhanced Performance
In this blog, we're diving into how switching to Azure Synapse Link can really save you money and boost your data performance. We'll walk…
Azure & Cloud Fundamentals
- Demystifying D365 F&O Data Export: A Guide to Microsoft's Data Export Solutions
Over the past few years, Microsoft has rolled out three new ways to export data from D365 F&O. With one of these already set for…
Azure & Cloud Fundamentals
- Managed Identities Explained
Managed Identities allow easy management of credentials lifecycle; access to any Azure Resource, API and SaaS that supports Azure AD Auth.
Azure & Cloud Fundamentals
- Choose the proper subscription and management group strategy
In my previous blog, we learned about, how various component creates logical or geographical boundaries. Today we will be learning about…
Azure & Cloud Fundamentals
- What is Azure Data Lake?
"Deep Dive into Azure Data Lake: Unleashing the Power of Big Data Storage and Analytics"
Azure & Cloud Fundamentals
- What is a Data Lake?
Diving into Data Lakes: A Beginner's Guide to Understanding the Basics
Azure & Cloud Fundamentals
- What is Data Lakehouse?
Exploring the Benefits of Data Lakehouse Architecture: A Scalable Solution for Storing and Analyzing Structured and Unstructured Data
Azure & Cloud Fundamentals
- Azure AD Architecture Explained
Learn about the architecture of Azure Active Directory , and see how various design patterns are used to design Azure AD
Azure & Cloud Fundamentals
- Azure Active Directory(Azure AD) Explained
Learn about Azure Active Directory, and how it helps protecting the user's identity and applications from security threats.
Azure & Cloud Fundamentals
- Best Practices in Spring Boot Project Structure
Learn about different layers of Microservice, how to create request body, DTO, and models, best practices, and versioning in spring…
Java & Spring Boot
- Consistency in Database
Learn data consistency in the databases, and when to use which type of consistency. Also, learn about different types of transactions.
Backend & Infra
- Dependency Injection Explained
Learn about dependency, different ways of providing a dependency to a class. and , how does spring boot injection dependency.
Java & Spring Boot
- How does Spring Boot Manage Dependency?
Learn about the management of dependencies; dependency scope; dependency versioning in Spring Boot. Also, learn about different classpath.
Java & Spring Boot
- Know your pom.xml
Learn about different components of pom and how each part of pom plays a crucial role in better software development.
Java & Spring Boot
- Do I need to scale my features?
In this blog, we will learn when we should scale the features. I usually divide Data Science projects into different pipelines: Exploratory…
Data Science
- Multi-Module Spring Boot Project with Azure
This blog, we will learn about spring boot multi-nodule project This projects enables easy integration with azure.
Java & Spring Boot
- Microsoft Azure Structure Explained
In my previous blog we discussed about Cloud Computing, and its type. From this blog, we will start diving deep in Microsoft Azure. We…
Azure & Cloud Fundamentals
- OSI Model Demystified
In this blog, we have taken an example of Netflix to unveil the secret of the OSI model. Communication is explained as in humans are…
Backend & Infra
- Is your Application Cloud-Ready
This blogs helps in understanding the why and how of cloud native apps.
Azure & Cloud Fundamentals
- Kubernetes Architecture Demystified
In this blog, I have unveiled the underhood working of Kubernetes, so that developers can get a better understanding of Kubernetes.
Backend & Infra
- Singleton Pattern Made Easy
In this blog, I have explained when, why and how of singleton pattern. I have also tired to relate singleton pattern with real life…
Software Engineering
- Cloud Computing: Making Life easier for companies
Before diving into Microsoft Azure, we should familiarize ourselves with basics of cloud computing, this will help us building a strong…
Azure & Cloud Fundamentals
- How to manage IoT devices at scale
In this blog, I have tried to simplified the explaination of Azure Device Provisioning Service
Azure & Cloud Fundamentals
- Is Abstraction a solution for most of your complex problem
In this blog, I have focused on how abstraction is solved some complex problem, and how it can solve some complex issue of your company.
Software Engineering
- What's new with Azure Backup
Microsoft is heavily investing in all possible security aspects. Recently they have launched a security update for Recovery Service Vault.
Azure & Cloud Fundamentals