Journal
Journal
Decision logs, behind the scenes, and "why I did it this way" pieces.
- 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
- 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.
- SponsoreddevrazziSkip the noise, read the signalCurated tech news and synthesis for developers. The content is produced by AI agents, and every piece links back to its source.
- 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
- 4 sections
Your Architecture Decisions Rot Because Nothing Runs Them
An architecture decision written in a wiki is a wish. The boundaries you can't enforce are the ones that quietly erode — until the diagram stops matching the code. Make the rule executable.
- 5 sections
AI Didn't Remove the Bottleneck — It Moved It
Cheap code production doesn't raise throughput if review, integration, and verification can't keep up. The bottleneck just moves downstream — and that's where the work now is
- 6 sections
Flaky Tests: Retrying Isn't a Fix
AI made writing tests nearly free, and flaky suites exploded. Why retry and quarantine are a treadmill, and what catches flakiness deterministically
- 5 sections
Schema Evolution: Changing a Contract Without Breaking It
A message's data shape is a contract across services you can't change atomically. The rule: additive is safe, a breaking change needs a new identity — and consumers upgrade first
- 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 — and it depends on whose hands shipped it.
- 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.
- 5 sections
The Production Cost of "Just-in-Case" Code
Applying YAGNI in practice: the price of adding flexibility you don't need today, repaid daily in maintenance, readability, and bug surface
- 5 sections
When I Move to Microservices
The measured signals that justify moving from a monolith to a distributed architecture — and the common false reasons that say it's still too early
- 8 sections
Gitflow or GitHub Flow? How I Choose
Practical criteria for picking a branching strategy by product model, version count, and deploy rhythm — and how each model breaks in the wrong place.
- 8 sections
When I Switch to Trunk-Based Development
Why release branches break for high-frequency deploy teams and how much of trunk-based is really discipline — the thresholds I cross and the ones I don't
- 5 sections
Why I Start Projects With a Modular Monolith
The case for drawing clean module boundaries inside a single deployable app before jumping to microservices — and when I stop doing it.
- 7 sections
Why I Prefer Boring Architecture
The pragmatic case for choosing proven tools over chasing new technology. This is not cowardice, it is a budget decision.
- 8 sections
My AI-Assisted Engineering Workflow
The seven rules I follow to use Claude Code and similar agents on production code with confidence — not a skeptical take, a discipline manifesto