Upgrade Triggers: Mandatory, Locking, Opportunity
A Dependabot PR, an EOL notice and a CVE bulletin share one queue but not one urgency. Sort signals into three types and give each a response time.
Engineering
Notes
Short technical notes and patterns straight from production.
-
- 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
- 6 sections
An Archiving Strategy: Old Data Without the Slowdown
Separating old records that bloat the live table: partitioning, cold storage, and keeping query access while you archive
- 7 sections
Sizing a PostgreSQL Queue Table by Its Live Set
On a queue table, an index and an autovacuum threshold that grow with the table scale wrong; the measured case for sizing both to the pending jobs
-
Indexes: Too Few Slow Reads, Too Many Kill Writes
A missing index slows the query; too many indexes make every write expensive. Striking the right balance by measurement, not by guesswork
-
Changing Schema in Production With Zero Downtime
Running migrations without causing downtime in production: backward-compatible steps, multi-phase column changes, and avoiding table locks
-
Read/Write Splitting: Separating Read and Write Load
Before scaling up the database: moving read traffic to replicas, the traps replication lag creates, and when you actually need it
- 6 sections
Before You Reach for Redis: The Right Cache Strategy
The questions to ask before adding a cache, why cache invalidation is hard, and the choice between TTL and consistency
- 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.
- 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
- 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
- 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
- 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
- 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.
- 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.
- 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
- 5 sections
Namespace Isolation for a Shared Redis
The pattern I use to avoid key collisions and accidental deletes when a single Redis instance is shared across several projects
-
A PostgreSQL Backup Strategy with pgBackRest
pg_dump alone is not a backup. A PITR-capable, compressed, verifiable backup architecture with pgBackRest.
- 6 sections
Why Do Laravel Queues Slow Down in Production?
Laravel queue workers are flawless locally and slow in production. The five most common reasons developers overlook.
- 6 sections
Nginx + PHP-FPM Pool Separation
The concrete benefits of defining a separate pool per application instead of a single PHP-FPM pool when running multiple PHP apps on one VPS