For a decade the default advice was "rewrite it as microservices." That advice was wrong for most teams, and the bill came due in network latency, distributed transactions, and an observability stack that cost more than the product. The modular monolith is the architecture most people actually wanted: strict internal boundaries inside a single deployable, with none of the distributed-systems tax.
Distributed-Systems
-
The Modular Monolith -
The Story of SQL How a 1970 IBM research paper on the relational model produced a declarative query language that outlasted its rivals, survived a decade-long NoSQL insurgency, and quietly absorbed the very systems that tried to replace it.
-
How Google Was Built The infrastructure decisions that turned a Stanford grad-student crawler into the company that taught the world to build distributed systems: PageRank, GFS, MapReduce, Bigtable, Chubby, Borg, Colossus, Spanner — and why the published papers mattered more than the code.
-
Game Theory in System Design Game theory is not a curiosity for economists. It is the design language for any system where independent parties act in their own interest — ad auctions, blockchains, consensus protocols, congested networks — and this post works through the math and the places it genuinely predicts, and fails to predict, real engineering behavior.
-
Error-Correcting Codes: From Hamming to Reed-Solomon Data does not survive storage and transmission by accident. Error-correcting codes — from the elegant simplicity of Hamming(7,4) to the polynomial algebra of Reed-Solomon — are what stand between your bits and a noisy, unreliable physical world. This post works through the mathematics that keeps your RAID array, NVMe drive, QR code, and deep-space telemetry intact.
-
Queueing Theory for Capacity Planning: Why Latency Explodes at 80% Queueing theory gives engineers a rigorous foundation for capacity planning. Little's Law, the M/M/1 utilization-latency formula, and the hockey-stick curve explain why latency degrades catastrophically near saturation — and exactly where to set thresholds for thread pools, connection pools, and HPA.
-
Consensus and Coordination: Raft, Paxos, and Why Agreement Is Hard Why getting a group of machines to agree on a single value is the root problem under etcd, Consul, Kafka, and every database you run — leader election, quorums and majorities, the FLP impossibility result in plain terms, Paxos vs Raft and why Raft won on understandability, log replication, split-brain and fencing, and how to reason about a cluster that has lost its leader.
-
Consistency, CAP, and Replication: The Tradeoffs You Cannot Escape CAP and the more useful PACELC reformulation, the spectrum of consistency models from linearizable to causal to eventual, single-leader vs multi-leader vs leaderless replication, quorum reads and writes (R + W > N), read-your-writes and monotonic guarantees, conflict detection, and how real systems like PostgreSQL, DynamoDB, and Cassandra pick their points on the curve. What 'eventually consistent' actually costs you.
-
Distributed SQL: CockroachDB, TiDB, and YugabyteDB NewSQL that survives a node dying while still speaking SQL. How Raft-replicated ranges deliver horizontal scale with strong consistency, the Google Spanner lineage the whole category descends from, multi-region survival goals and the latency tax they impose, online schema changes that don't lock the table, an honest head-to-head of CockroachDB, TiDB, and YugabyteDB — and the unglamorous truth that boring single-node Postgres still wins for most applications.
-
NATS: The Cloud-Native Nervous System NATS is a single-binary messaging backbone that scales from a two-node homelab to a global supercluster without a ZooKeeper sidecar, a broker fleet, or a PhD in configuration. This post covers core pub/sub and subject hierarchies, request/reply, queue groups, JetStream persistence and its KV and object stores, leaf-node topologies for edge deployments, the NKEYS/JWT security model, and an honest comparison to Kafka and RabbitMQ — including where each one actually wins.
-
RabbitMQ Deep Dive The full AMQP 0-9-1 model from producers to consumers, the four exchange types with routing examples, acknowledgement semantics and publisher confirms, quorum queues replacing classic mirrored queues via Raft consensus, streams as a Kafka-style append log, dead-letter exchanges and TTL, clustering and partition handling, and an honest accounting of when to reach for Kafka instead.
-
Time, Order, and CRDTs: Coordinating Without a Clock Why wall-clock time lies in distributed systems, Lamport timestamps and vector clocks, happens-before and causal ordering, the trouble with NTP and the appeal of TrueTime and hybrid logical clocks, and conflict-free replicated data types (CRDTs) for merge-without-coordination — with practical uses in collaborative editing, offline-first apps, and geo-distributed state.
-
Ceph as Software-Defined Storage: Block, File, and Object Across Every Platform What software-defined storage really means, why Ceph is the reference implementation, and how to actually consume it — RBD block, CephFS file, and RGW object — from Linux, macOS, and Windows, plus deep Proxmox integration and the networking that holds it all together.
-
Kafka Connect Deep Dive A comprehensive guide to Kafka Connect — connector architecture, Debezium CDC, Single Message Transforms, exactly-once delivery, schema evolution with Schema Registry, and running at scale on Kubernetes with Strimzi.
-
Apache Pulsar vs Kafka: Architecture, Trade-offs, and When to Choose Each Architecture differences, subscription models, multi-tenancy, geo-replication, tiered storage, schema registry, and an honest decision framework for choosing between Kafka and Pulsar in 2026.
-
etcd: The Brain of Kubernetes What lives in etcd, Raft consensus and quorum, backup and restore with etcdctl/etcdutl, compaction and defragmentation, the NOSPACE alarm, sizing guidelines, and the disaster recovery playbook.
-
Multi-Region Active-Active: What It Actually Takes Latency routing, conflict resolution, DynamoDB Global Tables, Aurora Global Database, RTO/RPO math, and why most teams shouldn't attempt full active-active.
-
OpenTelemetry in Practice: Tracing, Metrics, and Logs Without Vendor Lock-In A practical guide to OpenTelemetry: instrumenting real services with the SDK, running the Collector as a telemetry pipeline, exporting traces to Grafana Tempo, metrics to Prometheus, logs to Loki, and understanding context propagation and baggage.
-
Mixture of Experts Internals: Routing, Expert Parallelism, and Load Balancing MoE is now the default architecture for top-tier open models. This is how it actually works: router design, top-k token dispatch, auxiliary loss for load balancing, expert parallelism across GPUs, and what it means for inference serving — with DeepSeek-V3 and Mixtral as concrete case studies.
-
Temporal and Workflow Orchestration: Durable Execution for Engineers Who've Been Burned What makes Temporal different from a job queue, how event history replay achieves durable execution, activities vs workflows with real code, retries that actually work, self-hosting on Kubernetes, and an honest comparison with Celery, Airflow, and Step Functions.
-
Event Sourcing and CQRS in Production What event sourcing and CQRS actually cost in production — the appeal of storing what happened rather than current state, and the hard realities of lagging projections, schema migration, and replay that the seductive pitch leaves out.
-
The Outbox Pattern: Reliable Messaging Without Distributed Transactions The transactional outbox pattern for reliable messaging — how to atomically update your database and publish an event without distributed transactions, using a single local commit plus change data capture to drain the outbox.
-
Apache Spark Fundamentals: RDDs, DataFrames, Catalyst, and When Spark Still Wins How Apache Spark actually works under the hood — RDDs, DataFrames, the Catalyst optimizer, and the execution model — and an honest look at when Spark still wins versus DuckDB, Trino, Polars, and Flink.
-
Standalone Ceph Without Proxmox: cephadm, Pool Design, and Day-2 Operations Running Ceph on plain Linux without Proxmox hiding the complexity — bootstrapping with cephadm, designing pools and CRUSH rules for your hardware, exposing RBD, CephFS, and RGW, and the day-2 operations that keep a cluster healthy.
-
Elixir and the BEAM: Concurrency That Actually Scales A deep technical guide to Elixir and the BEAM VM — processes, OTP supervisors, GenServer, Phoenix LiveView, Ecto, distributed nodes, and an honest assessment of where the Erlang VM dominates and where it doesn't.
-
Scala: Functional Programming on the JVM A deep technical guide to Scala 3 — case classes, pattern matching, the type system, Cats, ZIO, build tooling, and an honest assessment of when Scala is the right choice and when it isn't.
-
Apache Kafka Deep Dive A comprehensive guide to Apache Kafka — how it works internally, producers and consumers, partitions and consumer groups, exactly-once semantics, schema management, and running Kafka reliably in Kubernetes with Strimzi.
-
Temporal for Durable Workflows: Replacing Fragile Cron Jobs and Distributed Sagas A comprehensive guide to Temporal — the durable execution engine that makes long-running, fault-tolerant workflows simple. Covers activities, workflows, signals, queries, schedules, child workflows, and running Temporal in production on Kubernetes.
-
Microservices Patterns That Work Microservices trade a hard problem you understand — a tangled monolith — for a set of hard problems you might not: network failure, partial outages, distributed data, and operational sprawl. This is a field guide to the patterns that make the trade survivable: how services should talk, how to stop failures cascading, how to manage data without distributed transactions, and the honest case for not splitting at all.
-
Event-Driven Architecture Explained Event-driven architecture trades the simplicity of a function call for loose coupling and scale, and the bill comes due in the hard parts: delivery semantics, ordering, the dual-write problem, schema evolution, and debugging a flow with no stack trace. A practical guide to what an event actually is, the patterns that work, and when not to reach for any of it.