sade.dev
TREN

A notebook on backend and systems engineering.

How every piece is built

  1. 01Context
  2. 02Constraint
  3. 03Approach
  4. 04Pitfalls
  5. 05Expiry

Featured

SystemTransactional Outbox: Dual-Write, Idempotent ConsumersClosing dual-write with an outbox, suppressing the at-least-once repeats it creates, and encrypting the personal data inside the event./10 sections

Latest42

Notes, systems write-ups and journal — one stream, newest first.

  1. Journal5 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

    #database#orm#sql#opinion
  2. Note6 sections

    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

    #postgresql#database#performance#indexing
  3. devrazziSkip 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. Note4 sections

    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

    #postgresql#database#migrations#production
  5. Note7 sections

    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

    #postgresql#database#scaling#performance
  6. Note6 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

    #caching#redis#performance#production
  7. Journal5 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

    #nosql#database#architecture#opinion
  8. Journal4 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.

    #postgresql#database#architecture#opinion
  9. Journal4 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

    #architecture#simplicity#decisions#opinion
  10. Note6 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.

    #resilience#architecture#api#production
  11. Note7 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

    #serverless#architecture#cloud
  12. Note6 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

    #architecture#api#bff
  13. Note7 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

    #architecture#queue#async#api
  14. System10 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.

    #architecture#messaging#idempotency#reliability#security
  15. Note5 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

    #architecture#event-driven#messaging
  16. System7 sections

    GPU FinOps with eBPF

    Why GPU spend is invisible to cgroup and cAdvisor metrics, how eBPF attributes it to teams — and the CUDA boundary only DCGM can cover.

    #ebpf#gpu#finops#observability#kubernetes
  17. System6 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.

    #kubernetes#gitops#spiffe#security#architecture
  18. Note5 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.

    #queue#dead-letter-queue#reliability#operations#architecture
  19. System5 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.

    #opentelemetry#observability#distributed-tracing#messaging#architecture
  20. Note4 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.

    #queue#schema#reliability#architecture
  21. Journal4 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.

    #architecture#governance#opinion

Search

Start typing. Notes, systems, journal, tools and pages.

↑↓move↵openescclose