Technical essays, architectural deep-dives, and practical guides at the intersection of code and design.
Page 1 of 30
A concrete, no-fluff playbook for engineers who want to thrive as AI takes over code writing: the skills to build, how to become T-shaped, how to use AI to learn faster instead of hollowing yourself out, and the exact habits for juniors and seniors to stay in demand.
A practical guide to reviewing AI-generated code: why it is a different job from normal code review, the characteristic places AI code breaks (edge cases, error handling, security, hallucinated APIs, wrong requirements), a six-step review flow, and the scaling trap every team now faces.
A practical method for debugging code an AI wrote: why it is harder than debugging your own code (no mental model), the disciplined reproduce-understand-isolate-verify loop, the common AI bug patterns, and how to use the AI itself to help debug without it leading you down a rabbit hole.
A grounded, non-hype take on what AI writing code actually means for software engineers: why your value moves up the stack, which roles are rising and which are shrinking, the things to watch out for, and why judgment — not typing speed — is the skill that now matters.
A clear explanation of the Transactional Outbox pattern: the dual-write problem (writing to the DB and a message broker separately is not atomic), how writing the business row and an outbox row in one transaction fixes it, how a relay or CDC publishes the events, and why consumers must still be idempotent.
A clear, practical guide to the Event Sourcing pattern: why storing an append-only log of events (instead of overwriting current state) gives you a perfect audit trail, time-travel and free read models, how snapshots keep it fast, event versioning, and how it pairs with CQRS — with a simple bank-account example.
A practical guide to Change Data Capture: what CDC is, why log-based CDC (reading the WAL/binlog with tools like Debezium) beats polling and triggers, how it powers search indexes, caches, data warehouses and DB-to-DB sync, and the real gotchas — ordering, at-least-once delivery, snapshots and schema changes.
A plain, practical explanation of CQRS (Command Query Responsibility Segregation): why separating the write model from the read model helps, how the two sides stay in sync through events, the eventual-consistency catch, and when you should (and should not) use it.
A practical explanation of the Circuit Breaker resilience pattern: the three states (closed, open, half-open), how it stops a slow dependency from cascading into a full outage, and how to combine it with timeouts, retries, bulkheads and fallbacks to build resilient systems.
An infrastructure performance guide: CDN/edge caching, load balancing, horizontal scaling and autoscaling, read replicas and queues — plus the scaling math (cache hit-ratio, tail amplification, Amdahl's law) that decides whether scaling out actually helps or just burns money.
The foundation of performance work: measure before you optimize. Why you track p95/p99 not the average, how to find the real bottleneck with profiling and tracing, and the three laws (Little's, Amdahl's, and the tail-at-scale effect) that tell you what's actually worth fixing — with measured numbers.
A practical, measured guide to backend application performance: the N+1 query problem, missing indexes, caching, connection pooling, async I/O, pagination and serialization — attacked in priority order, with real benchmark numbers showing why the database almost always dominates.