<p><strong>TLDR:</strong> Today’s content is light on news but heavy on fundamentals. A 10-rule latency guide covers the usual suspects — indexing, connection pooling, caching, and serialization — with an emphasis on profiling before optimizing. The outbox pattern gets a solid Go/Postgres walkthrough that’s worth bookmarking if you’ve ever dealt with dual-write failures. Data warehouse modeling also gets two separate treatments today, covering fact and dimension table design from basics through SCDs and partitioning.</p>
<hr>
<h2>Low-latency systems: 10 rules with trade-offs</h2>
<p>A practical breakdown of latency reduction techniques across the full request lifecycle — indexing, batching, connection pooling, payload compression, Protocol Buffers, and more. What makes it worth reading is the framing: profile first, optimize incrementally, and understand the trade-offs before reaching for any of these tools. Nothing groundbreaking here, but it’s a solid reference if you’re onboarding someone or auditing a system that’s started to slow down.</p>
<hr>
<h2>Outbox pattern in Go and Postgres</h2>
<p>This one covers the dual-write problem properly. The core issue is that a database commit and a message broker publish aren’t atomic — if the broker publish fails after the commit, you’re in an inconsistent state with no clean recovery path. The walkthrough implements the outbox pattern using a dedicated outbox table written within the same transaction, with a relay process using <code>FOR UPDATE SKIP LOCKED</code> to handle concurrent workers safely. There’s also a second approach using PostgreSQL’s WAL and logical replication via <code>pglogrepl</code> for lower-latency CDC without the outbox table overhead — that part alone is worth the read.</p>
<hr>
<h2>Data warehouse modeling: two takes on the same problem</h2>
<p>Two posts landed today on fact and dimension table design, which is either a coincidence or a sign that someone’s onboarding a data team. The first covers the structural basics — fact tables are narrow and row-heavy, dimension tables are wide and descriptor-heavy — plus SCDs and semi-additive measures. The second goes deeper into grain definition, surrogate keys, denormalization choices, partitioning, and data governance tooling. Neither is groundbreaking, but together they’re a reasonable reference for anyone setting up a warehouse schema from scratch.</p>
<hr>
<h2>Also notable</h2>
<ul>
<li><strong>ClickHouse in Ruby on Rails:</strong> A setup guide using the <code>clickhouse-activerecord</code> gem, covering multi-database config in <code>database.yml</code> and a base <code>ClickhouseRecord</code> model — useful if your Rails app is outgrowing Postgres for event analytics.</li>
</ul>


Query optimization, schema design, and data store coverage across PostgreSQL, MongoDB, Redis, and more.

Databases Digest

A curated roundup covering four practical backend topics. A 10-rule guide to low-latency systems emphasizes profiling before optimizing, covering indexing, connection pooling, caching, and serialization trade-offs. The outbox pattern gets a thorough Go/Postgres walkthrough addressing the dual-write problem, using a transactional outbox table with FOR UPDATE SKIP LOCKED for concurrent workers, plus a CDC alternative via PostgreSQL WAL and pglogrepl. Two complementary posts on data warehouse modeling cover fact/dimension table design, SCDs, grain definition, surrogate keys, and partitioning. A bonus tip covers integrating ClickHouse with Ruby on Rails via the clickhouse-activerecord gem.

Low-latency systems get a practical breakdown, outbox pattern lands in Go and Postgres