5 sections
Which Test Catches the Production Bug?
The real payoff of unit and integration tests: which one actually prevents production bugs, and where to spend your testing budget.
Engineering
Essays
Decision logs, behind the scenes, and “why I did it this way” pieces.
-
-
The Cost of Deferring an Upgrade
A PHP 7.1 → 8.2 upgrade was put off because "it works." The bill came later: a dependency lock, batched breaking changes, and bugs spread over months.
- 5 sections
Chasing 100% Coverage With Tests That Do Nothing
Test coverage is not a target, it's a byproduct. The cost of tests written to push the number up that catch no bugs at all
- 5 sections
The Cost of Installing a Package for Everything
The security, maintenance, and supply-chain cost of adding a dependency for a small function — and when writing it yourself is cheaper
- 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
- 5 sections
ORM or Native SQL?
Is the ORM making us lazy, or actually protecting us? The balance of safety, readability, and performance between the two approaches
- 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.
- 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
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.
- 5 sections
AI Didn't Remove the Bottleneck — It Moved It
Cheap code production doesn't raise throughput if review and integration can't keep up. The bottleneck moves downstream — that's where the work 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 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
- 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.
- 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.