The Curious Engineer

All blogs / Distributed systems / cloud

Arpit Bhayani

arpitbhayani.me

I document my learnings and views every week, and cover various topics that interest me. Here are all the blogs I wrote to date.

Distributed systems / cloudDatabasesAI / MLAlgorithms / data structures

’16’17’18’19’20’21’22’23’24’25’26
Posts
128 from 12 Apr 2016 to 24 Oct 2026
Posting
weekly (43 in the last year)
Kind
personal blog
Feed
https://arpitbhayani.me/rss.xml

2026 35

  1. Compiling a Workflow into a 3B Model
  2. PostgreSQL 19 Ships Property Graphs Enabling Direct Query of Existing Tables
  3. Quantization Fundamentals: How LLMs Run Efficiently with Reduced Memory and Fast Arithmetic
  4. Reorganizing KV cache memory can make models interactive in real-time
  5. Engineering Speed And Abstractions Create Longer Failure Paths, An Unacknowledged Tradeoff
  6. Organizing a Model's KV Cache Unlocks New Interactive Abilities
  7. Demystifying Kafka's Exactly-Once Semantics: Idempotence, Transactions, and Fencing
  8. AI makes pull requests less central in open-source contribution
  9. Cloudflare Implements Cache Transcoding to Optimize Cache Storage with Zstandard
  10. Consistent Hashing: Demystifying the Algorithm and Its Simple Implementation
  11. Choose a Depth, Not a Duration, To Navigate Rabbit Holes
  12. How Google Manages Billions of Lines of Code in a Single Monorepo
  13. Bitcask Explained: A Log-Structured, Fast Key-Value Store
  14. Design Multi-Context Processing Tools as Capabilities, Not Endpoints
  15. Deckrun: A Modern Presentation Utility for Markdown and Self-contained HTML
  16. Slop Debt
  17. What AI First Engineering Orgs Look Like
  18. Three Claude Skills I Think Every Org Should Have
  19. G-Eval, Explained
  20. HyperLogLog: Efficient Cardinality Estimation with Probabilistic Data Structures
  21. How Redis Implements Strings: A Deep Dive into SDS and Encoding
  22. AI Workflows Need Topological Sort
  23. Embedding Models Make Or Break Your Ai App
  24. Temporal Primer - Building Long-Running Systems
  25. What Matters in Production RAG
  26. Structure of Every LLM Chat
  27. How LLMs Really Work
  28. Your Monolith Is Already A Distributed System
  29. The Curse of Dimensionality
  30. Databases Were Not Designed For This
  31. Bm25
  32. JOIN Algorithms
  33. Why Half Your Skills Expire Every Few Years
  34. Multi-Paxos - Consensus in Distributed Databases
  35. MySQL Replication Internals

2025 19

  1. Bloom Filters
  2. Clock Synchronization Is a Nightmare
  3. When You Increase Kafka Partitions
  4. Product Quantization
  5. The Q, K, V Matrices
  6. How LLM Inference Works
  7. What are Blocking Queues and Why We Need Them
  8. Heartbeats in Distributed Systems
  9. How Writes Work in Apache Cassandra
  10. Redis Replication Internals
  11. How Does a CDN Handle Content Replication
  12. Why gRPC Uses HTTP2
  13. Why Distributed Systems Need Consensus Algorithms Like Raft
  14. Why Do Databases Deadlock and How Do They Resolve It
  15. Why and How Cache Locality Can Make Your Code Faster
  16. Why Eventual Consistency is Preferred in Distributed Systems
  17. Why does DNS use both UDP and TCP
  18. How to Write Effective OKRs
  19. Theta sketches: set algebra over massive streams

2024 6

  1. When to Change Jobs - The 3P Framework
  2. Paper Notes - On-demand Container Loading in AWS Lambda
  3. Paper Notes - SQL Has Problems. We Can Fix Them Pipe Syntax In SQL
  4. Paper Notes - NanoLog - A Nanosecond Scale Logging System
  5. Paper Notes - WTF - The Who to Follow Service at Twitter
  6. Turn System Design Interviews into Discussions

2023 1

  1. How to Remain Unblocked

2022 7

  1. Solving the Knapsack Problem with Evolutionary Algorithms
  2. Generating Pseudorandom Numbers with LFSR
  3. Local vs Global Indexes in Partitioned Databases
  4. Partitioning Data - Range, Hash, and When to Use Them
  5. Partitioning Strategies for Distributed Databases
  6. Leaderless Replication
  7. Multi-Master Conflicts - How to Handle Them

2021 21

  1. Multi-Master Replication - Why Conflicts Happen
  2. Multi-Master Replication - Scaling Writes Across Geographies
  3. Monotonic Reads - How Asynchronous Replication Creates Wormholes
  4. Read-Your-Writes Consistency
  5. What Happens When a Master or Replica Fails
  6. Replication Formats - Statement vs Row-based
  7. Replication Strategies - Synchronous, Asynchronous, and Semi-Synchronous
  8. Master-Replica Replication
  9. Decoding Durability - The D in ACID
  10. Decoding Isolation - The I in ACID
  11. Decoding Atomicity - The A in ACID
  12. Decoding Consistency - The C in ACID
  13. Architectural Patterns for Distributed Systems
  14. Fallacies of Distributed Computing Every Engineer Should Know
  15. Fork Bomb
  16. Python Internals - Exploring Chained Comparison Operators
  17. Modeling Udemy's Categories in a Relational Database
  18. I Changed the Rules for the Python's Walrus Operator
  19. Fully Persistent Arrays
  20. How Persistent Data Structures Work
  21. Constant Folding in Python

2020 35

  1. How Python Uses String Interning to Keep Runtime Efficient
  2. Visualizing Recursion in Python with Just a Decorator
  3. Count Distinct With Minimal Memory - Flajolet Martin Algorithm
  4. The 2Q Algorithm - Addressing LRU's Sub-Optimality
  5. Israeli Queues
  6. 1D Terrain Generation
  7. MinHash - Fast Jaccard Similarity at Scale
  8. Time Series Smoothing for Anomaly Detection
  9. Implementing LFU in O(1)
  10. Space-Efficient Counting - Exploring Morris' Algorithm
  11. Why Slowsort is Hilariously Inefficient
  12. Bitcask - A Log-Structured fast KV store
  13. Phi Accrual Failure Detection Algorithm
  14. Breaking Repeating-Key XOR Encryption
  15. ETAOIN SHRDLU - Using Letter Frequency to Decipher the Ciphered
  16. Making Integers Iterable in Python
  17. Structure Composition and Emulating Inheritance in C
  18. The RUM Conjecture - Storage System Trade-offs
  19. Consistent Hashing - What It Is and How to Implement It
  20. How Python Handles Integers Under the Hood
  21. Fractional Cascading - Speeding Up Multiple Binary Searches
  22. Copy-On-Write - When to Use It, When to Avoid It
  23. How MySQL Avoids Performance Hits from Table Scans
  24. Modeling Finite State Machines with Python Coroutines
  25. Building Better Ratings with Bayesian Averages
  26. Sliding Window Rate Limiting - Design and Implementation
  27. The Intuition Behind IDF
  28. Habits that Make a Great Programmer
  29. Python Prompt Strings
  30. Rule 30 - Generating Random Numbers with Cellular Automata
  31. Python's Missing Feature - Function Overloading
  32. Isolation Forest - Fast and Efficient Anomaly Detection
  33. Image Steganography
  34. How Python Handles Gigantic Integers
  35. Python Internals - I Made Addition Unpredictable

2017 3

  1. Analyzing MongoDB Pagination Performance Differences
  2. MongoDB Pagination - Skip is Slow
  3. MongoDB Pagination - Two Approaches You Need to Know

2016 1

  1. HTTP - The Hard Way with Netcat