Note 6 sections
CQRS: When You Need It, When It's Dead Weight
Separating read and write models: the clarity CQRS buys in a complex domain, and the dead weight it adds to plain CRUD
All tags
Tag
#architecture
29 entries: Note, System, Essay.
-
- Essay 5 sections
Is Your Data Really Big, or Just Badly Modeled?
Most big-data problems are really bad modeling or a missing index; before moving to a distributed system, ask whether the data is actually big
- Essay 5 sections
The NoSQL Trap: Starting Because "It Has No Schema"
The consistency and data-integrity crises that projects which moved to NoSQL for the comfort of going schemaless eventually hit
- Essay 4 sections
Is PostgreSQL Enough for Everything?
Before adding a separate search engine, queue, or document DB: how far PostgreSQL gets you on its own, and where its limit begins.
- Essay 4 sections
Signals That a System Has Grown Too Complex
The concrete red flags that reveal code or architecture has turned needlessly complex — and where to start simplifying
- Note 6 sections
Circuit Breakers for External Service Integrations
Connecting a critical system to external APIs: using timeouts, retries, and circuit breakers to stop one service's collapse from taking the whole system down.
- Note 7 sections
The Serverless Decision: Cold-Start and Vendor Lock-in
Before you move to FaaS: the real cost of cold-start latency, vendor lock-in risk, and the workloads where serverless actually pays off
- Note 6 sections
BFF Pattern: A Separate API Layer for Mobile and Web
Separate API layers for mobile and web: the hidden cost of bending one API to fit every client, and when a BFF is actually warranted
- Note 7 sections
Synchronous or Asynchronous? HTTP or the Queue
Should a job run inside the HTTP request or go to a queue? The decision line, drawn through response time and fault tolerance
- System 10 sections
Transactional Outbox: Dual-Write, Idempotent Consumers
Closing dual-write with an outbox, suppressing the at-least-once repeats it creates, and encrypting the personal data inside the event.
- Note 5 sections
Event-Driven Architecture: What It Solves and Hides
The price of loose coupling through events: balancing the flexibility it buys against the risk of making your system's flow impossible to trace
- System 6 sections
Zero Static Authority in Multi-Cluster GitOps
Multi-cluster GitOps with no long-lived kubeconfig: SPIFFE IDs, SPIRE-issued short-lived SVIDs — the order to build it in, and what each step costs.
- System 5 sections
Distributed Tracing Across a Polyglot Queue
Turning a message that crosses PHP, Go and Python over a frozen envelope into one OpenTelemetry trace — no new field, no new dependency.
- Note 5 sections
Replaying a Dead-Letter Queue Without Making It Worse
Naive replay re-poisons the queue or double-fires side effects. The safe shape: reset, dry-run, sandbox-first, select.
- Essay 4 sections
Architecture Decisions Rot Because Nothing Runs Them
An architecture decision written in a wiki is a wish. The boundaries you can't enforce quietly erode until the diagram stops matching the code.
- Note 4 sections
Validating the Schema at the Edge of the Queue
A message's data is an untyped contract the queue won't check. Validate it at the edge: producer before publish, consumer as a safety net.
- Note 7 sections
Idempotency: When the Same Message Arrives Twice
At-least-once delivery means a handler will see the same message twice. The idempotency key, where it comes from, and the dedupe that survives a crash
- Essay 5 sections
Schema Evolution Without Breaking the Contract
You can't change a cross-service contract atomically. The rule: additive is safe, a breaking change needs a new identity — consumers upgrade first
- Essay 4 sections
Can You Ship Vibe-Coded Software to Production?
Vibe coding lowers the cost of a first version, not the cost of being wrong. That bill arrives in production, not at build time.
- Essay 5 sections
Layered Architecture or Clean Architecture?
Why the classic layered structure is enough for most projects while we drown in abstraction layers, and when Clean Architecture actually pays off.