Learn Software Architecture as a connected topic across chapters, concepts, simulations, and interview reasoning.

LLM Engineering

A production-first guide to picking the right vector index for recall, latency, memory, and update patterns.

ANN Index Types Explained: When to Choose Flat, HNSW, IVF, or IVF-PQ

Big Data Engineering

Master the art of tracking data movement, debugging pipelines, and meeting compliance requirements

Data Lineage Explained: Tracking Data Flow Across Your Organization

Build a governance framework: metadata management, access control, and compliance without the bureaucracy

Data Governance Essentials: Framework and Best Practices

Software Engineering Principles

A practical glossary of credential-stuffing defenses every engineering team should operationalize

OWASP Credential Stuffing Key Terms Explained with Practical Examples

Machine Learning Fundamentals

Why every neural network classifier converts its raw output through exponential normalization before calling it a prediction

Softmax Function Explained: From Raw Scores to Probabilities

System Design Interview Prep

Consistent hashing rings, adaptive capacity, and chunk balancers — how the three leading NoSQL databases partition data at scale

NoSQL Partitioning: How Cassandra, DynamoDB, and MongoDB Split Data

Virtual threads replace thread pools for I/O work. Structured concurrency replaces CompletableFuture. Java 21 LTS is the biggest release since Java 8.

Java 21 to 25: Virtual Threads, Pattern Matching, and Structured Concurrency

Records eliminated boilerplate. Sealed classes enforced type hierarchies. Pattern matching removed redundant casts. Java 17 LTS made it stable.

Java 14 to 17: Records, Sealed Classes, Text Blocks, and Pattern Matching

Data Structures and Algorithms

How stochastic averaging over leading-zero bit runs estimates cardinality to ±0.81% using 12 KB of memory regardless of dataset size.

HyperLogLog Explained: Counting Billions of Unique Items with 12 KB

From cosine similarity to scaled dot-product attention — how one operation powers modern AI

Dot Product in Machine Learning: The Engine Behind Similarity, Attention, and Neural Networks

How a d × w counter matrix answers 'how often has X appeared?' with a bounded upper bound error and O(1) operations at any stream volume.

Count-Min Sketch Explained: Frequency Estimation at Streaming Scale

Why wall clocks diverge, how NTP drift breaks Last-Write-Wins, and how vector clocks and HLC restore causal ordering

Clock Skew and Causality Violations: Why Distributed Clocks Lie

How a bit array and k hash functions answer 'definitely not in this set' in O(1) — and why false negatives are mathematically impossible.

Bloom Filters Explained: Membership Testing with Zero False Negatives

How replication lag creates stale read windows, which consistency models fix them, and how a single slow node triggers a self-reinforcing cascade

Stale Reads and Cascading Failures in Distributed Systems

How network partitions create two leaders, why that produces irrecoverable data loss, and the quorum, fencing, and STONITH patterns that prevent it

Split Brain Explained: When Two Nodes Both Think They Are Leader

How PostgreSQL and MySQL use range, hash, list, and composite partitioning to eliminate unnecessary I/O — and when NOT to partition at all

SQL Partitioning: Range, Hash, List, and Composite Strategies Explained

How lambdas, streams, Optional, and Java 9 modules transformed Java from verbose boilerplate to expressive, maintainable code

Java 8 to 11: Lambdas, Streams, Modules, and the End of Boilerplate

A practical decision guide with Python code for both paths — choose the right approach before you spend weeks building the wrong one.

RAG vs Fine-Tuning: When to Use Each (and When to Combine Them)

From the math of low-rank decomposition to running QLoRA on a single A100 — everything you need to fine-tune a 70B model without a supercomputer.

Fine-Tuning LLMs with LoRA and QLoRA: A Practical Deep-Dive

A practical decision framework with cost analysis, latency benchmarks, and Python code for both paths — so you pick right the first time.

Build vs Buy: Deploying Your Own LLM vs Using ChatGPT, Gemini, and Claude APIs

Apache Spark Engineering

Late events are inevitable in distributed systems — watermarks tell Spark exactly when it is safe to finalize a window without waiting forever

Watermarking and Late Data Handling in Spark Structured Streaming

Treats streams as unbounded tables — the execution model determines whether your pipeline hits milliseconds or minutes.

Spark Structured Streaming: Micro-Batch vs Continuous Processing

mapGroupsWithState gives you a per-key mutable state machine in a streaming pipeline — it is the right tool when windows are not enough

Stateful Aggregations in Spark Structured Streaming: mapGroupsWithState

A Spark shuffle moves every matching key across the network — understanding when and why is the difference between a 2-minute and 2-hour job

Shuffles in Spark: Why groupBy Kills Performance

The format you choose for Spark I/O determines whether predicate pushdown saves you 90% of a scan or reads every byte

Reading and Writing Data in Spark: Parquet, Delta, JSON, and JDBC

Partition count and strategy determine whether your Spark job scales linearly or falls apart at 10x data — here is what happens under the hood

Partitioning in Spark: HashPartitioner, RangePartitioner, and Custom Strategies

How Spark runs on Kubernetes using the Spark Operator, Dynamic Resource Allocation, pod templates, and Prometheus metrics for production observability

Spark on Kubernetes: Operator, Dynamic Allocation, and Production Monitoring

Kafka delivers events, Spark processes them — offset management, schema evolution, and exactly-once delivery determine production reliability

Kafka and Spark Structured Streaming: Building a Production Pipeline

A deep dive into Spark's JVM memory regions, executor core arithmetic, G1GC vs ZGC trade-offs, and the config knobs that actually matter

Spark Executor Sizing: Memory Model, Core Tuning, and GC Strategy

Catalyst turns your DataFrame ops into an optimized physical plan — understanding it explains why column pruning and predicate pushdown are free

Spark DataFrames and Spark SQL: Schema, DDL, and the Catalyst Optimizer

Caching in Spark is lazy and partition-level — understanding how StorageLevel and eviction work is the difference between a speedup and an OOM

Caching and Persistence in Spark: Storage Levels and When to Use Them

Spark picks your join strategy automatically — knowing when it picks wrong and why saves hours of debugging slow join stages

Broadcast Joins vs Sort-Merge Joins in Spark

Why your Spark job fails with OOM at the same stage every time — and how understanding the driver, DAG scheduler, and executors fixes it

Spark Architecture: Driver, Executors, DAG Scheduler, and Task Scheduler Explained

How AQE re-optimizes query plans at runtime using real shuffle statistics to eliminate skew, prune partitions, and coalesce small tasks

Spark Adaptive Query Execution: Dynamic Coalescing, Pruning, and Skew Handling

Python Programming

The 15 Python idioms that separate Java-style Python from code that actually belongs in the language

Pythonic Code: Idioms Every Developer Should Know

Python OOP isn't Java OOP — from __init__ to dataclasses to __slots__, here's what actually matters

Python OOP: Classes, Dataclasses, and Dunder Methods

How Python's lazy evaluation turns infinite sequences and billion-row pipelines into single-line code

List Comprehensions, Generators, and Lazy Evaluation in Python

Why Python functions work nothing like Java methods — and how mastering them unlocks everything from decorators to async

Functions in Python: Parameters, Return Values, and Scope

Python's functional tools are not just map/filter — itertools and functools turn complex data transformations into composable one-liners

Functional Python: map, filter, itertools, and functools

Why try/except in Python is not just error-catching — it's a flow control tool that makes production code robust

File I/O and Exception Handling in Python

Decorators are just functions wrapping functions — once you see that, Flask routes, pytest fixtures, and dataclass fields all make sense

Decorators Explained: From Functions to Frameworks

Python's built-in collections aren't just syntax — their internals determine whether your code runs in O(1) or O(n)

Python Data Structures: Lists, Dicts, Sets, and Tuples

Why Python variables work nothing like Java — and why that makes them more powerful

Python Basics: Variables, Types, and Control Flow

Why async Python is not about parallelism — it is about not wasting CPU while waiting for I/O

Async Python: asyncio, Coroutines, and Event Loops Without the Confusion

How CosmosDB maps your partition key to physical storage — and why the wrong choice costs 10x more at scale

CosmosDB Partition Internals: Logical vs Physical Partitions Explained

Supervised fine-tuning, parameter-efficient LoRA, and reinforcement learning from human feedback — when to use each and how to implement them

Fine-Tuning LLMs: The Complete Engineer's Guide to SFT, LoRA, and RLHF

The prompting technique that unlocked multi-step reasoning in LLMs — and how to use it effectively in production

Chain of Thought Prompting: Teaching LLMs to Think Step by Step

How modern AI skips millions of training hours by reusing pretrained knowledge — and when to freeze, fine-tune, or train from scratch

Transfer Learning Explained: Standing on the Shoulders of Pretrained Models

Why LLMs confidently make things up, how to detect it, and the practical strategies engineers use to keep production AI grounded

LLM Hallucinations: Causes, Detection, and Mitigation Strategies

From the query-key-value formulation to multi-head attention — the mechanism that made transformers dominate AI

Attention Mechanism Explained: How Transformers Learn to Focus

How It Works: Internals Explained

How MoE replaces the dense FFN with N expert layers and a learned router — GPT-4-scale capacity at a fraction of inference cost

Sparse Mixture of Experts: How MoE LLMs Do More With Less Compute

Inside the dense transformer block — attention heads, FFN layers, and why scaling dense models hits a wall

Dense LLM Architecture: How Every Parameter Works on Every Token

A practical decision guide for choosing between managed LLM APIs and self-hosted open-weight deployments.

Managed API LLMs vs Self-Hosted Models: When to Switch and When Not To

A practical field guide to prompt spaghetti, missing evals, runaway costs, and the moment an LLM feature becomes too much.

LLM Software Development Pitfalls: What to Avoid and When to Simplify

From the CMPXCHG CPU instruction to DynamoDB ConditionExpressions and Cassandra LWT — how CAS and optimistic locking work across every major database.

Compare-and-Swap and Optimistic Locking: How Every Database Implements It

How DynamoDB Streams, Cosmos DB, CockroachDB, MongoDB, and Debezium capture changes — delivery semantics, ordering, and when not to use CDC.

Change Feed vs Change Stream: CDC Internals, Reliability, and When to Avoid Each

From WAL and MVCC to fsync and isolation levels — the internals behind every ACID guarantee in PostgreSQL, MySQL, Oracle, and SQL Server.

ACID Properties Explained: How SQL Databases Guarantee Atomicity, Consistency, Isolation, and Durability

Horizontal, vertical, SQL, and NoSQL partitioning strategies — a map of every approach and when to use each

Partitioning Approaches in SQL and NoSQL: Horizontal, Vertical, Range, Hash, and List Partitioning

How uncommitted row overwrites corrupt cross-table state — and why row locks are the critical safeguard in every relational database.

Dirty Write Explained: When Uncommitted Data Gets Overwritten

How a transaction can read two objects at different points in time, violating invariants that no single committed state ever broke.

Read Skew Explained: Inconsistent Snapshots Across Multiple Objects

How concurrent read-modify-write operations silently discard one transaction's changes — and four ways to prevent it from overselling your inventory.

Lost Update Explained: When Two Writes Become One

How concurrent inserts and deletes make a range query return different rows within a single transaction — and why only Serializable stops it.

Phantom Read Explained: When New Rows Appear Mid-Transaction

Two transactions check a shared condition and write to different rows — individually correct, collectively wrong. Why Repeatable Read fails.

Write Skew Explained: The Anomaly That Requires Serializable Isolation

How a single uncommitted write can corrupt downstream reads, cause phantom transactions, and what isolation levels prevent it.

Dirty Read Explained: How Uncommitted Data Corrupts Transactions

Why reading the same row twice in one transaction can return different committed values — and which isolation level finally stops it.

Non-Repeatable Read Explained: When the Same Query Returns Different Results

Inside the architecture of Claude Code, GitHub Copilot, and Cursor: how agents use LLMs, manage context windows, handle sessions, and tier memory.

How AI Coding Agents Work: Models, Context, Sessions, and Memory

From Minor GC to ZGC: how each Java garbage collector manages heap memory and what it means for your application's latency and throughput.

How JVM Garbage Collection Works: Types, Memory Impact, and Tuning

Migrate your Spring Boot services from thread-pool exhaustion to JDK 21 virtual threads — the practical Spring developer guide

Adapting to Virtual Threads for Spring Developers

Every major Java feature from 8 to 25 — lambdas, records, sealed classes, virtual threads, pattern matching, and what they replace

Java 8 to Java 25: How Java Evolved from Boilerplate to a Modern Language

A taxonomy of the anomalies that distributed systems produce beyond SQL transaction isolation — and the engineering patterns that prevent them

Data Anomalies in Distributed Systems: Split Brain, Clock Skew, Stale Reads, and More

How PostgreSQL, MySQL, Cassandra, DynamoDB, and MongoDB implement sharding — the trade-offs every system designer must know

Sharding Approaches in SQL and NoSQL: Range, Hash, and Directory-Based Strategies Compared

What read committed commits to, why repeatable read still allows phantoms in some databases, and when you actually need serializable isolation

Isolation Levels in Databases: Read Committed, Repeatable Read, Snapshot, and Serializable Explained

Every term you'll encounter in distributed systems interviews and production engineering — defined clearly with examples

Key Terms in Distributed Systems: The Definitive Glossary

A deep comparison of how relational and NoSQL databases detect, prevent, and accept different classes of data anomalies

Database Anomalies: How SQL and NoSQL Handle Dirty Reads, Phantom Reads, and Write Skew

How modern NoSQL databases achieve atomicity and isolation without a single machine

ACID Transactions in Distributed Databases: DynamoDB, Cosmos DB, and Spanner Compared

Beyond redundancy: How to build systems that survive regional outages and infrastructure failures.

Designing for High Availability: The Road to 99.99% Reliability

Beyond 'Strong vs Eventual': Navigating the subtle trade-offs of distributed agreement.

The Consistency Continuum: From Read-Your-Own-Writes to Leaderless Replication

Beyond the SQL vs NoSQL debate: A framework for matching database architecture to business requirements.

Choosing the Right Database: CAP Theorem and Practical Use Cases

What each consistency level actually guarantees — and the production pitfalls that happen when you get it wrong

Azure Cosmos DB Consistency Levels Explained: Strong, Bounded Staleness, Session, Consistent Prefix, and Eventual

What each API can and cannot do — and the compatibility gaps that break production migrations

Azure Cosmos DB API Modes Explained: NoSQL, MongoDB, Cassandra, PostgreSQL, Gremlin, and Table

Architecture Patterns for Production Systems

Why NoSQL consistency is harder than you think — and the per-database patterns that fix it

The Dual Write Problem in NoSQL: MongoDB, DynamoDB, and Cassandra

Transactional Outbox, CDC publishing, and cache invalidation — the patterns that eliminate dual write failures

The Dual Write Problem: Why Two Writes Always Fail Eventually — and How to Fix It

How to choose the right uniqueness strategy — from 6-char short URLs to distributed int64 order IDs

ID Generation Strategies in System Design: Base62, UUID, Snowflake, and Beyond

Master Big O notation: measure algorithm efficiency from O(1) to O(n²) with growth diagrams, worked examples, and the interview mental model.

Big O Notation Explained: Time Complexity, Space Complexity, and Why They Matter in Interviews

Trade exact answers for fixed memory and O(1) operations: a comparative guide to Bloom Filters, HyperLogLog, and Count-Min Sketch.

Probabilistic Data Structures: A Practical Guide to Bloom Filters, HyperLogLog, and Count-Min Sketch

Why log-based capture succeeds in some databases and silently fails in others — and what to do when your database doesn't expose a log.

How CDC Works Across Databases: PostgreSQL, MySQL, MongoDB, and Beyond

Skip lists, dual indexing, and the five production patterns every backend engineer reaches for.

Redis Sorted Sets Explained: Skip Lists, Scores, and Real-World Use Cases

The celebrity threshold, Redis sorted sets, and the hybrid model every social platform actually ships.

Write-Time vs Read-Time Fan-Out: How Social Feeds Scale

Collapse O(n²) pair-search problems to O(n) by converging two index boundaries on a sorted array.

Two Pointer Technique: Solving Pair and Partition Problems in O(n)

A Trie stores strings character by character — enabling O(L) prefix queries no HashMap can match.

Tries (Prefix Trees): The Data Structure Behind Autocomplete

Eliminate redundant subarray re-scanning by maintaining a running aggregate across an expanding and shrinking boundary.

Sliding Window Technique: From O(n·k) Scans to O(n) in One Pass

Sort once, sweep once: three full Java solutions for the merge intervals pattern used in every scheduling system.

Merge Intervals Pattern: Solve Scheduling Problems with Sort and Sweep

Master prev, curr, and next — the three-pointer pattern that unlocks full reversal, sub-list reversal, and K-group rotation in O(1) space.

In-Place Reversal of a Linked List: The 3-Pointer Dance Every Interviewer Expects

Detect cycles, find their starts, and locate list midpoints — all in O(n) time and O(1) space.

Fast and Slow Pointer: Floyd's Cycle Detection Algorithm Explained

DFS explores graphs by going as deep as possible before backtracking — the key to cycle detection and path search.

DFS — Depth-First Search: Go Deep Before Going Wide

Software Architecture

Overview

How this topic helps

Learning Path in this Topic

Articles