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

Latest49

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

  1. Journal5 sections

    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.

    #technical-debt#decisions#dependencies#opinion
  2. Journal5 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

    #testing#quality#opinion
  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. Journal5 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

    #dependencies#security#simplicity#opinion
  5. Note6 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

    #architecture#cqrs#patterns
  6. Note6 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

    #postgresql#database#performance#production
  7. Journal5 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

    #database#scaling#architecture#opinion
  8. Note7 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

    #postgresql#queue#performance#indexing#production
  9. 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
  10. 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
  11. 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
  12. 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
  13. 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
  14. 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
  15. 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
  16. 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
  17. 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
  18. 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
  19. 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
  20. 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
  21. 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

Search

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

↑↓move↵openescclose