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.
Architecture
-
The Modular Monolith -
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.
-
Web Performance Engineering Making pages fast, measured properly — Core Web Vitals (LCP, INP, CLS) and what actually moves them, the critical rendering path, resource hints, lazy loading and code-splitting, caching and CDN strategy, image and font optimization, and measuring with lab tools and real-user monitoring. The SRE mindset applied to the frontend.
-
The Case for Boring Technology Why proven tools often beat the latest frameworks.
-
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.
-
Database Design Fundamentals Principles for designing database schemas that scale and perform.
-
Caching Strategies for Performance How to implement caching effectively at different layers of your application.
-
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.
-
The Twelve-Factor App Methodology The twelve-factor methodology is the reason a modern app can be torn down and rebuilt anywhere from its source and config alone. This is a walk through all twelve factors grouped by what they actually buy you — portability, disposability, and scale — plus an honest look at where the 2011 manifesto shows its age in a world of containers, Kubernetes, and secret managers.