Protecting services from overload with rate limiting. Token bucket and leaky bucket algorithms explained with Java implementations and real-world trade-offs.
Backpressure: When Consumers Can’t Keep Up
Handling slow consumers in distributed systems. Queue growth, memory exhaustion, and strategies for applying backpressure - rejection, rate limiting, and flow control.
Retry Strategies: Exponential Backoff and Jitter
How to retry failed requests without overwhelming servers. Exponential backoff, jitter, and when to give up. Java implementations and real-world patterns.
Idempotency: Why Retries Need It
How to make operations safe to retry. Idempotency keys, database patterns, and why retrying non-idempotent operations causes data corruption.
Session Guarantees: The Promises Your Database Makes to You
Read-your-writes and monotonic reads aren’t just buzzwords. They’re the difference between a database that feels broken and one that makes sense to users.
Horizontal vs Vertical Scaling: Bigger Machine or More Machines
Comparing vertical scaling (scale up) and horizontal scaling (scale out). When to use each, trade-offs, and the complexity that comes with horizontal scaling.
Circuit Breakers: Failing Fast to Stay Alive
How circuit breakers prevent cascading failures in microservices. State transitions, Java implementation with Resilience4j, and real-world thresholds.
Load Balancing Strategies: Picking the Right Server
Comparing load balancing algorithms - Round Robin, Least Connections, Weighted Round Robin, and IP Hash. Java implementations and real-world trade-offs.
Bloom Filters: Definitely Not Here
Bloom filters skip unnecessary disk reads in LSM trees by saying ‘definitely not here’ with zero false negatives. Learn how Cassandra and RocksDB use them.
Compaction Strategies: Cleaning Up After LSM Trees
LSM trees create SSTables fast but need compaction. Learn size-tiered vs leveled compaction strategies and the write vs read amplification tradeoff.
LSM Trees vs B-Trees: Write Fast or Read Fast
LSM Trees vs B-Trees: the write-fast or read-fast tradeoff. Learn when to use B-trees (MySQL) vs LSM trees (Cassandra) based on your database workload.
Write-Ahead Logging: How Databases Survive Crashes
How do databases survive crashes and ensure durability? Learn how Write-Ahead Logging (WAL) uses sequential writes to guarantee data persistence without killing performance.
Read Repair and Anti-Entropy: Healing Stale Replicas
How do stale replicas catch up in distributed systems? Compare read repair and anti-entropy strategies with Merkle trees for healing data divergence.
Conflict Resolution: When Two Writes Win
Concurrent writes in distributed databases don’t merge automatically. Learn to detect conflicts with version vectors and resolve them without losing data.
Replication Lag: The Bug That Isn’t a Bug
Users see stale data after writes. It’s not a bug, it’s replication lag. Learn to handle read-after-write problems and causality violations in production.
Consistency Models: What Eventually Means
Eventual consistency doesn’t mean milliseconds. Understand linearizability, causal consistency, and quorum reads to pick the right consistency model.
Query Execution Plans: Reading EXPLAIN Like a Map
Stop staring at EXPLAIN output confused. Learn to read MySQL execution plans like a map and find the root cause of slow queries in seconds, not hours.
Secondary Indexes in Distributed Databases
Querying partitioned databases by non-partition keys? Learn the tradeoffs between local and global secondary indexes in distributed systems.
The Hidden Cost of JOINs
Every JOIN multiplies query complexity. Learn the three JOIN strategies databases use and when denormalization beats JOIN performance by 30x.
Indexing Strategies That Actually Work
More indexes don’t mean faster queries. Learn when to add, remove, and optimize database indexes. Real examples of 7x performance gains through strategic indexing.
Virtual Nodes: The Three-Layer Pattern of Consistent Hashing
Understand virtual nodes in consistent hashing through a simple three-layer model that decouples data distribution from server topology in distributed systems.
The Query Optimization Framework
Stop guessing at performance problems. Learn the 5-step systematic framework for debugging slow queries that helped reduce query times from 2+ seconds to 30ms.
How to create a Media Server out of a router
Transform your OpenWrt router into a media server using MiniDLNA and Samba. Step-by-step guide for USB storage setup and network media streaming.
How I managed to deploy a 2 node ceph cluster
Deploy a 2-node Ceph storage cluster on CentOS 7 for learning or OpenStack integration. Complete setup guide with network configuration and OSD deployment.
Import GPG key in CentOS 7
Fix GPG key errors in CentOS 7 when installing packages. Quick solution using rpm –import to resolve yum repository GPG verification issues.
Yet Another Network Controller (Part 2) – Running YANC
Run YANC with Mininet to create OpenFlow network topologies. Complete tutorial for starting yanc filesystem, of-adapter, and connecting with Mininet.
Yet Another Network Controller (Part 1) – Getting started
Get started with YANC (Yet Another Network Controller) on Linux. Step-by-step setup guide for yanc filesystem and yanc-of-adapter with OpenFlow switches.
How to Build Java Projects on-the-fly using Apache Ant’s API
Build Java projects programmatically using Apache Ant’s Java API. Learn to compile code, create WAR files, and deploy on-the-fly without build.xml.
How To Setup Your Own Web Server with or without a Network Router
Turn your PC into a web server using WampServer. Complete tutorial for setting up Apache with or without a router, including port forwarding and configuration.
My First ‘Self-Made’ Swing Application
Building my first Java Swing application: Click Tester. Learn how to create a simple GUI app that tests clicking speed using JButton, JLabel, and Stopwatch.