Tag
#architecture
27 articles: Journal, Note, System.
- 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
- 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 Migration 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
The 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? The Line Between HTTP and 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
- 10 sections
Transactional Outbox: Dual-Write, At-Least-Once, and Idempotent Consumption
Writing to the database but failing to put the event on the queue: closing dual-write with an outbox, suppressing the at-least-once repeats it creates, and encrypting the field.
- 5 sections
Event-Driven Architecture: When It Saves You, When It Adds Complexity
The price of loose coupling through events: balancing the flexibility it buys against the risk of making your system's flow impossible to trace
- 6 sections
Zero Static Authority in Multi-Cluster GitOps
GitOps across many Kubernetes clusters with no long-lived kubeconfig or token. SPIFFE IDs, SPIRE-issued short-lived SVIDs, trust-domain federation — the order to build it in, and what each step costs.
- 5 sections
Replaying a Dead-Letter Queue Without Making It Worse
The DLQ filled up during an outage and you want it back. Naive replay re-poisons the queue or double-fires side effects. The safe shape: reset, dry-run, sandbox-first, select.
- 5 sections
Distributed Tracing Across a Polyglot Queue
A message crosses PHP, Go and Python over a frozen envelope. Turning its journey into one OpenTelemetry trace with no new field and no core dependency — and the honest limit of that.
- 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-side before publish, consumer-side as a safety net, against a per-URN schema
- 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.
- 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
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
- 10 sections
Race Conditions and Gaps in Sequential Numbering: JIT Reservation
Generating legally sequential, gap-free numbers with parallel workers: the JIT reservation pattern that solves race conditions and gaps together
- 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
- 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.
- 9 sections
Scale Breaking Points in Data-Intensive Systems
As data load grows, where does boring architecture break? Working set, read replicas, partitioning, write load and a separate data layer — the breaking points in order, and what each one costs
- 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.
- 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
- 11 sections
Multiple Projects on a Single VPS
One VPS, several independent apps. Deliberate minimalism over Kubernetes: user isolation, separate PHP-FPM pools, shared PostgreSQL/Redis, a plain deploy.
- 13 sections
Laravel Production Stack
A production-grade Laravel setup with Nginx + PHP-FPM + Redis + PostgreSQL + Supervisor + Horizon. Each piece's job and what you lose if you drop it