60 essays. No sponsorships, no newsletter popups — just things I think about on the train home.
A set of real-world microservices case studies from fintech, banking, and highload consumer products — what problem each team faced, which approach they picked, and the code that actually shipped.
The practical patterns for logging and debugging distributed Java systems — what to log, what never to log, how to make logs useful at 3 AM, and the debugging techniques that actually work when the bug only reproduces in production.
A walkthrough of taking a monolithic Java backend through the scaling journey — what we changed at each stage, what broke, and the concrete decisions that moved the needle when traffic grew 50×.
How to actually know what your distributed system is doing in production — the three signals, the tools that compose them, and the operational discipline that turns telemetry from cost center into debugging superpower.
The unvarnished version. What actually breaks in production Java microservices, the lessons that don't show up in architecture talks, and the small habits that separate teams that sleep at night from teams that don't.
How distributed systems stay up when traffic moves from hundreds to hundreds of thousands of requests per second — the architectural decisions, trade-offs, and failure modes that actually matter at scale.
What actually breaks when a Java backend grows from hundreds of users to hundreds of thousands — and the concrete patterns, code, and trade-offs that keep it standing.
A field guide to the microservices patterns that earn their keep — what problem each one solves, when to reach for it, and what it looks like in Java code.
Java 26 is shaping up to be one of the more impactful non-LTS releases — pattern matching on primitives, compact headers default-on, and more. What to plan for.
How to actually build microservices on the JVM — the frameworks that matter, the patterns you'll reach for, and concrete code for a small order-processing system built with Spring Boot.
A practical introduction to microservices architecture — what it is, why teams adopt it, the core building blocks, and the trade-offs you inherit the moment you move away from a monolith.
Why averages lie, what p95/p99/p999 actually tell you, and how to pick SLO targets that match real user experience.
A practical tour of Java 25's backend-relevant additions — what's final, what's still preview, and which features to actually adopt in production code today.
What Gradle configurations actually are, why implementation vs api vs compileOnly matter, and the custom configurations that solve real production problems.
Transactional outbox and Change Data Capture solve the same problem differently. The practical trade-offs, and how to decide between them for your system.
The real trade-offs of native-image compilation for Java services — startup, memory, throughput — and the friction that stops most teams from adopting it universally.
The structure and conventions that make Gradle multi-module projects maintainable as they grow — module boundaries, build logic reuse, and the traps to avoid.
The most-preached and least-followed rule of microservices. Why teams bend it, what breaks when they do, and the practical patterns for keeping services data-independent.
What actually happens when you flip the virtual threads switch on a Spring Boot service — the wins, the sharp edges, and when the old thread-pool model still beats them.
The BFF pattern, why it often beats a single generic API, and how to avoid turning your BFFs into a new kind of monolith.
Which garbage collector to pick for a Java backend in 2025, the handful of flags that actually matter, and the signs your choice is wrong.
Google's SRE book is 500 pages long and targets 100-engineer orgs. For a 10-person team, the pragmatic subset that delivers most of the benefit at a fraction of the cost.
Backoff, jitter, bounded attempts, and the retriable-vs-non-retriable error classification that separates resilience from retry storms.
Why default HikariCP is almost right, the four settings worth tuning deliberately, and the symptoms that tell you something is off.
How circuit breakers actually behave in production, tuning the state transitions, and the subtle interactions with retries and timeouts that cause most outages.
Cache-aside, write-through, read-through, and the stampede protection that separates a cache from a foot-gun. With concrete Java examples.
Why contract testing replaces most of your end-to-end suite, how Pact and Spring Cloud Contract fit in, and the workflow that makes teams actually adopt it.
What a blameless postmortem actually looks like, why "blameless" is harder than it sounds, and the structure that turns incidents into system improvements.
How to replace legacy systems one slice at a time without a big-bang rewrite. The pattern, the gates, and the traps that stretch migrations into years.
How Postgres streaming replication actually works, setting up replicas that don't lag, and the failover mechanics you must rehearse before production.
Token bucket, leaky bucket, sliding window — what each actually does, and the practical implementation in distributed systems.
URL versioning, header versioning, media-type versioning — their real trade-offs, and how to pick a strategy you won't regret two years in.
The optimizations that let one Postgres instance handle tens of thousands of transactions per second, and the signs that it's time to think beyond a single node.
What DLQs are, why you must have one for every message consumer, and the operational patterns that keep bad messages from blocking the good ones.
The three main tenancy models, their trade-offs at scale, and a hybrid approach that often beats the pure cases.
Why every non-trivial backend needs idempotency keys, the common designs, and the mistakes that let duplicates slip through anyway.
The modern Java data modeling trio — records for immutable data, sealed types for closed hierarchies, and pattern matching to glue them together. What it looks like in real code.
Audit logs sound trivial and get messy fast. The data model, the event capture, and the retrieval patterns that make audit logs useful instead of write-only.
Why you need a schema registry the moment you have more than one consumer, how Avro and Protobuf compare, and the compatibility rules that prevent production accidents.
Why "save to DB, then publish to Kafka" is almost always wrong, and the outbox pattern that fixes it — with real Java code, schema, and production considerations.
The mental model for Java Streams that makes them actually click — lazy evaluation, short-circuiting, the collectors you actually use, and the gotchas that bite every team.
The architecture of a notification service that delivers to web, mobile, email, and SMS reliably at scale. Channel fanout, user preferences, and the delivery guarantees that matter.
How to coordinate operations across services that each have their own database. Orchestrated vs choreographed sagas, compensating actions, and when to use which.
What message brokers are, why distributed systems need them, and how to choose between Kafka, RabbitMQ, NATS, and friends for your use case.
A pragmatic intro to Kafka Streams — what it is, what it gives you over plain consumers, and the honest operational cost.
The parts of Spring Boot you'll use on every project, the parts you'll almost never touch, and the mental model that separates the two.
The things nobody tells you about event sourcing until you've run it in production — snapshot strategies, schema evolution, event stream hygiene, and when to walk away.
What actually matters when designing a product search — indexing, relevance, aggregations, and the operational realities that turn "let's use Elasticsearch" into a multi-month project.
The idea behind DI demystified — why it's the foundation of every modern Java framework, how it compares to alternatives, and the pitfalls that make teams hate it.
How consumer groups actually work, what triggers a rebalance, and the configuration that turns rebalances from outages into smooth handoffs.
Storing events instead of state — what it is, what it buys you, and the situations where the complexity is worth the audit trail and replayability.
Writing the contract before the code — why it changes how teams collaborate, how it catches bugs early, and the tooling that makes it painless in Java projects.
The data models and constraints that make a banking ledger both performant and provably correct, learned the hard way over several years of building them.
Command Query Responsibility Segregation explained from first principles — the problem it solves, when it's overkill, and what it looks like in real Java systems.
A practical comparison of REST and gRPC for inter-service communication. When each wins, the real trade-offs, and how most production systems end up using both.
The mental model for Kafka partitions, how ordering works (and doesn't), and the partition-key choices that determine everything downstream.
What matters when you're building the code that moves money. Idempotency, double-entry accounting, consistency, and the operational realities of payment rails.
The essential ideas behind distributed systems, explained without the PhD jargon. What breaks when you cross a process boundary, and the patterns that exist to handle it.
Why DDD and microservices fit so well together, and the handful of DDD concepts that actually matter when you're drawing service boundaries.
A practical playbook for breaking a monolith into services without stopping the product. The order of operations, the patterns that make it safe, and the traps that waste months.
Nothing matches. Try a different tag.