Series
How It Works: Internals Explained
Ever wondered what actually happens when you trigger a function, commit a transaction, or deploy a container? This series peels back the layers of abstraction to explore the low-level mechanics of modern technology. From database engines and operating system internals to the hidden plumbing of distributed systems, we dive deep into the source code and architectural designs that make complex software work. No magic, just engineering.
31
Articles
10h 28m
Estimated reading
Intermediate to Advanced
Knowledge level
1,043
Readers
About this series
Ever wondered what actually happens when you trigger a function, commit a transaction, or deploy a container? This series peels back the layers of abstraction to explore the low-level mechanics of modern technology. From database engines and operating system internals to the hidden plumbing of distributed systems, we dive deep into the source code and architectural designs that make complex software work. No magic, just engineering.
Series Progress
0% Complete0 of 31 articles viewed
Continue Learning
Who is this for?
Software engineers and developers learning this topic.
Knowledge Level
Intermediate to Advanced
Last Updated
May 25, 2026
Created by
Abstract Algorithms
All Articles
Article 1
Sparse Mixture of Experts: How MoE LLMs Do More With Less Compute
TLDR: Mixture of Experts (MoE) replaces the single dense Feed-Forward Network (FFN) layer in each Transformer block with N independent expert FFNs plus a learned router. Only the top-K experts activat
27 min read
Article 2
Compare-and-Swap and Optimistic Locking: How Every Database Implements It
TLDR: Compare-and-Swap (CAS) is the CPU-level atomic instruction that makes lock-free concurrency possible. Optimistic locking builds on it at the database layer: read freely, compute locally, write o
34 min read
Article 3
Change Feed vs Change Stream: CDC Internals, Reliability, and When to Avoid Each
In the summer of 2023, the platform team at a fast-growing e-commerce company was handling 100,000 orders per day across three microservices: Order Service, Inventory Service, and Billing Service. All
49 min read
Article 4
ACID Properties Explained: How SQL Databases Guarantee Atomicity, Consistency, Isolation, and Durability
TLDR: ACID is four orthogonal guarantees that every SQL transaction must provide. Atomicity says all-or-nothing: PostgreSQL implements it via WAL rollback; MySQL InnoDB via undo logs. Consistency says
38 min read
Article 5
How AI Coding Agents Work: Models, Context, Sessions, and Memory
TLDR: An AI coding agent is an LLM stapled to a tool registry, wrapped in an orchestration loop that painstakingly rebuilds state on every single API call — because the model itself is completely stat
34 min read
Article 6
How JVM Garbage Collection Works: Types, Memory Impact, and Tuning
TLDR: JVM garbage collection automatically reclaims unused heap memory, but every algorithm makes a different trade-off between throughput, latency, and memory footprint. The default G1GC targets 200m
25 min read
Article 7
ACID Transactions in Distributed Databases: DynamoDB, Cosmos DB, and Spanner Compared
TLDR: ACID transactions in distributed databases are not equal. DynamoDB provides multi-item atomicity scoped to 25 items using two-phase commit with a coordinator item, but only within a single regio
39 min read
Article 8
The Consistency Continuum: From Read-Your-Own-Writes to Leaderless Replication
TLDR: In distributed systems, consistency is a spectrum of trade-offs between latency, availability, and correctness. By leveraging session-based patterns like Read-Your-Own-Writes and formal Quorum l
8 min read
Article 9
Azure Cosmos DB Consistency Levels Explained: Strong, Bounded Staleness, Session, Consistent Prefix, and Eventual
TLDR: Cosmos DB offers five consistency levels — Strong, Bounded Staleness, Session, Consistent Prefix, Eventual — each with precise, non-obvious internal mechanics. Session does not mean HTTP session
25 min read
Article 10
Azure Cosmos DB API Modes Explained: NoSQL, MongoDB, Cassandra, PostgreSQL, Gremlin, and Table
TLDR: Cosmos DB's six API modes are wire-protocol compatibility layers over one shared ARS storage engine — except PostgreSQL (Citus), which is genuinely different. Every API emulates its native datab
24 min read
Article 11
Probabilistic Data Structures: A Practical Guide to Bloom Filters, HyperLogLog, and Count-Min Sketch
TLDR: Probabilistic data structures trade a small, bounded probability of being wrong for orders-of-magnitude better memory efficiency and O(1) speed. Bloom Filters answer "definitely not in this set"
14 min read
Article 12
How CDC Works Across Databases: PostgreSQL, MySQL, MongoDB, and Beyond
A data engineering team at a fintech company built what they believed was a robust Change Data Capture pipeline: three source databases (PostgreSQL, MongoDB, and Cassandra), Debezium connectors wired
37 min read
Article 13
Redis Sorted Sets Explained: Skip Lists, Scores, and Real-World Use Cases
TLDR: Redis Sorted Sets (ZSETs) store unique members each paired with a floating-point score, kept in sorted order at all times. Internally they use a skip list for O(log N) range queries and a hash t
20 min read
Article 14
What are Hash Tables? Basics Explained
TLDR: A hash table gives you near-O(1) lookups, inserts, and deletes by using a hash function to map keys to array indices. The tradeoff: collisions (when two keys hash to the same slot) must be handl
12 min read
Article 15
Understanding Inverted Index and Its Benefits in Software Development
TLDR TLDR: An Inverted Index maps every word to the list of documents containing it — the same structure as the back-of-the-book index. It is the core data structure behind every full-text search eng
15 min read
Article 16
X.509 Certificates: A Deep Dive into How They Work
TLDR: An X.509 Certificate is a digital document that binds a Public Key to an Identity (e.g., google.com). It is digitally signed by a trusted Certificate Authority (CA). It prevents attackers from i
16 min read
Article 17
How Transformer Architecture Works: A Deep Dive
TLDR: The Transformer is the architecture behind every major LLM (GPT, BERT, Claude, Gemini). Its core innovation is Self-Attention — a mechanism that lets the model weigh relationships between all to
18 min read
Article 18
How SSL/TLS Works: The Handshake Explained
TLDR: SSL (now TLS) secures data between your browser and a server. It uses Asymmetric Encryption (Public/Private keys) once — to safely exchange a fast Symmetric Session Key. Everything after the han
16 min read
Article 19
How OAuth 2.0 Works: The Valet Key Pattern
TLDR: OAuth 2.0 is an authorization protocol. It lets a third-party app (like Spotify) access your resources (like Facebook Friends) without you giving it your Facebook password. It uses short-lived A
16 min read
Article 20
How Kubernetes Works: The Container Orchestrator
TLDR TLDR: Kubernetes (K8s) is an operating system for the cloud. It manages clusters of computers (Nodes) and schedules applications (Pods) onto them via a continuous declarative control loop — you
13 min read
Article 21
How Kafka Works: The Log That Never Forgets
TLDR: Kafka is a distributed event store. Unlike a traditional queue (RabbitMQ) where messages disappear after reading, Kafka stores them in a persistent Log. This allows multiple consumers to read th
13 min read
Article 22
How GPT (LLM) Works: The Next Word Predictor
TLDR: At its core, GPT asks one question, repeated: "Given everything so far, what is the most likely next token?" Tokens are not words — they're subword units. The Transformer architecture uses self-
15 min read
Article 23
How Fluentd Works: The Unified Logging Layer
TLDR: Fluentd is an open-source data collector that decouples log sources from destinations. It ingests logs from 100+ sources (Nginx, Docker, syslog), normalizes them to JSON, applies filters and tra
12 min read
Article 24
How Bloom Filters Work: The Probabilistic Set
TLDR TLDR: A Bloom Filter is a bit array + multiple hash functions that answers "Is X in the set?" in \(O(1)\) constant space. It can return false positives (say "yes" when the answer is "no") but ne
13 min read
Article 25
How Apache Lucene Works: The Engine Behind Elasticsearch
TLDR: Lucene is a search library. Its core innovation is the inverted index — a reverse map from words to documents, like the index at the back of a textbook. Documents are stored in immutable segment
15 min read
Article 26
Consistent Hashing: Scaling Without Chaos
TLDR: Standard hashing (key % N) breaks when \(N\) changes — adding or removing a server reshuffles almost all keys. Consistent Hashing maps both servers and keys onto a ring (0–360°). When a server i
13 min read
Article 27
BASE Theorem Explained: How it Stands Against ACID
TLDR TLDR: ACID (Atomicity, Consistency, Isolation, Durability) is the gold standard for banking. BASE (Basically Available, Soft state, Eventual consistency) is the standard for social media. BASE i
14 min read
Article 28
A Guide to Raft, Paxos, and Consensus Algorithms
TLDR TLDR: Consensus algorithms allow a cluster of computers to agree on a single value (e.g., "Who is the leader?"). Paxos is the academic standard — correct but notoriously hard to understand. Raft
13 min read
Article 29
Webhooks Explained: Don't Call Us, We'll Call You
TLDR: Webhooks let one system push event data to another the moment something happens. Instead of polling ("anything new?"), you expose an endpoint and the provider POSTs signed event payloads to you
13 min read
Article 30
Java Memory Model Demystified: Stack vs. Heap
TLDR: Java memory is split into two main areas: the Stack for method execution frames and primitives, and the Heap for all objects. Understanding their differences is essential for avoiding stack over
14 min read
Article 31
Types of Locks Explained: Optimistic vs. Pessimistic Locking
TLDR: Pessimistic locking locks the record before editing — safe but slower under low contention. Optimistic locking checks for changes before saving using a version number — fast but can fail and req
13 min read
How It Works: Internals Explained — Learning Roadmap
You're staring at a production dashboard at 2 AM. Your Kafka consumers are lagging behind by millions of messages. Your Kubernetes pods are stuck in Pending state. Your database queries that ran fine yesterday are timing out. The alerts are firing, the phones are ringing, and you realize something unsettling: you know what is broken, but not why.
This is the moment when surface-level knowledge fails you. When Stack Overflow answers and vendor documentation hit their limits. When understanding the internals transforms from "nice to have" to "career-saving." System internals aren't academic curiosity — they're your debugging superpower. When you understand how Kafka's log segments work, you know where to look when consumer lag spikes. When you grasp Kubernetes' scheduler internals, you can diagnose why pods won't schedule. When you comprehend how hash tables handle collisions, you can optimize that slow lookup that's killing your API response times.
TLDR: This decision-tree roadmap guides you through 18 system internals posts across 4 learning tracks — choose your role (Backend, Security, AI/ML, or Infrastructure Engineer) to get a personalized learning path from data structures to distributed systems to cutting-edge AI architectures.
What You'll Learn
Understand How It Works: Internals Explained through real published examples
Follow a sequence of 31 articles from fundamentals to deeper topics
Connect related concepts: llm, mixture of experts, transformers
Practice explaining trade-offs and implementation decisions
Prerequisites
FAQs
How should I read this series?
Start from the first article if you are new, or use the article list to jump into the most relevant topic.
Is progress automatic?
Progress is based on articles opened from this browser using the local learning history.