The instruction-set war of the 1980s and 90s ended in the strangest way possible: both sides won. How x86 swallowed RISC whole, how ARM grew CISC-grade complexity, and why the ISA matters less than the business model wrapped around it.
Architecture
-
RISC vs CISC: The War That Ended in a Tie -
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.
-
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.
-
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.
-
AWS EventBridge in Depth Event buses, schema discovery, archives and replay, Pipes for point-to-point integration, Scheduler for replacing cron jobs, cross-account routing, and real-world patterns including the saga.
-
Cloud Database Trade-offs: RDS vs Aurora vs DynamoDB vs ElastiCache When to use RDS, Aurora, Aurora Serverless v2, DynamoDB, and ElastiCache. Connection pooling with RDS Proxy, single-table DynamoDB design, partition hotspots, Valkey, and the cost math.
-
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.
-
PostgreSQL Full-Text Search vs Elasticsearch: Where the Line Actually Is tsvector/tsquery, pg_trgm fuzzy matching, ranking and highlighting, multilingual support, and an honest answer to when Postgres FTS is enough and when you actually need a dedicated search engine.
-
Serverless in Production: Lambda Patterns That Hold Up A practical guide to running AWS Lambda in production: the cold start problem and its real solutions, concurrency and throttling mechanics, event-driven fan-out with SQS and SNS, Step Functions for durable orchestration, API Gateway cost traps, container images vs layers, idempotency, and the patterns that break under load.
-
ADRs in Practice: Architecture Decision Records That Teams Actually Read Why Architecture Decision Records keep teams from re-litigating settled choices — what to capture, how to structure an ADR, where to store them, and how to make them documents engineers actually read and reference.
-
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.
-
Strangler Fig for Legacy Migrations: Replacing Systems Without the Big Rewrite How to replace a legacy system incrementally with the strangler fig pattern — routing traffic through a façade and migrating functionality piece by piece — instead of betting the company on a multi-year big-bang rewrite.
-
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.
-
Redis Beyond Caching: Streams, Pub/Sub, Search, and When Redis Is Your Primary Database A deep dive into Redis beyond the cache: pub/sub messaging, Streams for event logs, RedisJSON for document storage, RediSearch for full-text search, persistence modes, and HA with Cluster vs Sentinel.
-
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.
-
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.