Skip to the content
Software Made Clear
Search the whole site About

TOPIC 25 ARTICLES

Architecture & System Design

Boundaries, transaction scope, queues, and the distributed-system failures that follow from all three — written from systems already running when I arrived.

Help me choose a first step
LATEST IN ARCHITECTURE & SYSTEM DESIGN Event sourcing explained: rebuild state from events

EXPLORE THE TOPIC

Browse the articles

Pick a question that interests you, or narrow the list above.

DEEP DIVE Event sourcing explained: rebuild state from events Replay a cart's events, load a snapshot and see a stale read model catch up. Compare event sourcing with CQRS and ordinary event delivery. Read it →
DEEP DIVE Events, and what they promise Find out what an event actually guarantees once it leaves the service that raised it, and which of those promises the consumer has to absorb itself. Read it →
DEEP DIVE Transaction boundaries Choose which changes must commit together, keep remote calls outside local transactions, and test the failure gap with an interactive outbox example. Read it →
DEEP DIVE Transactional outbox: a crash and retry example Step through an outbox crash, compare direct publishing, and run a SQLite example showing why a saved message can still be delivered twice. Read it →
DEEP DIVE Twelve-Factor app configuration: what belongs in the environment? Keep one build while changing deployment settings. Try missing values and a preview pointing at production, then review secret delivery and rotation. Read it →
DEEP DIVE Serverless architecture: what the provider manages Follow a serverless image job, change where its result is saved, and see how cold starts, scaling, retries and service limits affect the design. Read it →
COMPARISON SOA vs microservices Compare an ESB-centred service design with microservices, change a message contract, and see why independent deployment still needs compatible boundaries. Read it →
DEEP DIVE Exponential backoff See why retries hit hardest exactly when a system is already failing, why spacing them out is not enough on its own, and where the multiplication comes from. Read it →
COMPARISON gRPC vs REST See what a binary contract between two services buys you and what it costs in reach, so the choice follows your callers rather than the fashion. Read it →
DEEP DIVE Idempotency keys and safe retries Give every retry a key, store its result in the same transaction as the effect, and stop worrying whether a lost response means the work happened twice. Read it →
COMPARISON Latency vs throughput Learn why a system can get busier and slower at the very same time, and work out which of the two numbers your users are really complaining about. Read it →
DEEP DIVE Load balancers, concretely See how round robin, least connections and a hash actually differ, and which of them stops working the moment a server keeps anything in its own memory. Read it →
DEEP DIVE Rate limiting See what the HTTP specification fixes about rate limiting, what it deliberately leaves to you, and why the counter you pick decides the burst you allow. Read it →
DEEP DIVE HTTP 202 background jobs: accepted is not completed Follow one background export from HTTP 202 to a finished file. Separate job status from a lost connection, and make retries and user messages tell the truth. Read it →
DEEP DIVE Characterization tests: make an AI refactor safer Record existing behaviour before an AI refactor. Run a cancellation example that catches an accidental change, and separate preservation from correctness. Read it →
DEEP DIVE Architecture decision records Record why an architecture choice was made, which assumptions could change it, and when to review it without rewriting the history of the decision. Read it →
DEEP DIVE CRDTs explained: merge a counter across two replicas Follow two offline replicas through a concrete counter merge, then see why delivery rules, deletes, metadata costs, and global invariants still matter. Read it →
COMPARISON Unit vs integration test Compare test boundaries with a runnable booking example: a fake accepts duplicate slots while SQLite rejects them. See what each check establishes. Read it →
DEEP DIVE Bounded contexts, concretely See how bounded contexts keep different meanings separate, translate external API facts at the edge, and avoid a shared model that spreads confusion. Read it →
DEEP DIVE Consistent hashing explained with a key movement example Compare modulo sharding with a hash ring, then see exactly which keys move when a node joins and what virtual nodes, replication, and hot keys change. Read it →
DEEP DIVE Dead letter queues See the four things that actually send a message to a dead letter queue, why only one of them is your code failing, and how the cycle protection works. Read it →
DEEP DIVE Distributed tracing See what one header has to carry for a request to stay one story across a dozen services, and why the identifiers are standardised but the meaning is not. Read it →
DEEP DIVE Strangler-fig migration, from the inside Replace a running production system without stopping it, and see the routing and data-ownership decisions that actually determine whether it survives. Read it →
DEEP DIVE What a Kafka topic actually is See what a topic really is on disk, why order holds inside one partition and nowhere else, and what that single fact decides about your consumers. Read it →
DEEP DIVE When a message broker is the wrong answer See three real systems that reached for a queue to patch a missing transaction boundary, and what broke later because a broker cannot supply one. Read it →