Database Tech with Fexingo: SQL, NoSQL, and Data Storage Conversations

Episode 130 dives deep into a single database index technique—the Bloom filter—and shows how it saves millions of disk seeks per second. Lucas explains how a probabilistic data structure with zero false negatives can check whether a key exists without touching storage, using an in-memory bit array and a handful of hash functions. He walks through the classic use case: Apache Cassandra's bloom_filt...

Lucas and Luna dig into why database cursors cause memory blowups when naive streaming is used instead of proper pagination. Using a real-world example of a Postgres query that crashed an analytics dashboard by fetching 2 million rows at once, they explain the mechanics of server-side cursors, client-side buffering, and why LIMIT/OFFSET is not the answer. The episode walks through a concrete fix:...

Lucas and Luna dive into database deadlock handling, comparing wait-die and wound-wait schemes. Using a concrete example from PostgreSQL 17's transaction manager, they explain how these protocols prevent deadlocks without the overhead of a deadlock detector. The episode covers why wait-die is safer for read-heavy workloads while wound-wait favors writes, and how Amazon Aurora's distributed archite...

Lucas and Luna explore HTAP — hybrid transactional-analytical processing — and why it's becoming essential for real-time decision-making. They break down the trade-offs between separate OLTP and OLAP systems versus a unified engine, using concrete examples from financial fraud detection and e-commerce inventory management. The episode explains how columnar storage and in-memory computing enable HT...

Lucas and Luna dive into read-write splitting: why the database's own query planner can't be trusted to route traffic efficiently. They dissect a real-world case where a mid-size e-commerce platform in Berlin suffered cascading replication lag because its application layer sent analytical queries to the primary. The fix? A proxy-based read-write splitter with a consistent hash ring that steered re...

In this episode of Database Tech with Fexingo, Lucas and Luna explore a subtle but critical failure mode in distributed databases: sharding without a consistent hash ring. Using the real-world example of a fintech startup that saw 70% of its query traffic go to a single shard after a rebalance, they explain why naive modulo-based sharding breaks under node additions and removals. They walk through...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the overlooked but critical topic of database connection timeouts and adaptive retry logic. They explore why fixed timeouts and naive retries can cascade into system-wide failures, using real-world examples like a major payment processor's 2023 outage and Netflix's exponential backoff strategy. Lucas explains the trade-offs be...

Episode 123 of Database Tech with Fexingo. Lucas and Luna dissect a production nightmare: CDC pipelines delivering duplicate events to a downstream analytics warehouse. They explain why change data capture without exactly-once semantics leads to phantom revenue numbers, and how tools like Debezium and Kafka handle offset commits, idempotent sinks, and out-of-order events. Using a concrete example...

Lucas and Luna dive into the perils of asynchronous replication by examining a real-world outage at a major social media platform in early 2026. They explain why async replication created a multi-hour inconsistency that caused incorrect friend counts and messaging failures. Then they break down quorum-based replication — both Raft and Paxos — and how a simple majority write quorum would have preve...

Vector databases are everywhere now, but most teams slap an HNSW index on their embeddings without understanding why it works or when it breaks. Lucas and Luna drill into the Hierarchical Navigable Small World graph structure — how it layers neighbor graphs from coarse to fine, why the search time scales logarithmically instead of linearly, and the one tuning parameter that kills recall if you set...

Lucas and Luna dig into the neglected art of database compression. While most engineers know run-length encoding for repetitive columns, dictionary encoding often delivers 5x better compression on low-cardinality string data without the decompression tax at query time. They walk through a real example: a 500-million-row ecommerce table storing payment method strings like 'Visa', 'Mastercard', 'Ame...

Lucas and Luna dive into the trade-offs between size-tiered and leveled compaction in LSM-tree databases like Cassandra and RocksDB. They explain why choosing the wrong compaction strategy for your workload can lead to write amplification, read stalls, and disk space bloat. Using a real-world example from an ad-tech company with a 10-to-1 write-to-read ratio, they show how switching from leveled t...

In this episode, Lucas and Luna dive into why traditional materialized views break under real-time data workloads and how incremental refresh strategies—like PostgreSQL's materialized view CONCURRENTLY or Oracle's FAST REFRESH—save both time and compute. They use a concrete example from a mid-size e-commerce company that saw query latency drop from 12 seconds to 200 milliseconds after switching to...

Episode 117 of Database Tech with Fexingo: Lucas and Luna tackle covering indexes — a specific indexing strategy that can eliminate table lookups entirely. They explain how a typical B-tree index works in a PostgreSQL-like database, then contrast it with a covering index that includes all columns needed by a query. Using a concrete example from an e-commerce order table, they walk through the quer...

Episode 116 of Database Tech with Fexingo. Lucas and Luna dive into write skew, a subtle concurrency anomaly that breaks snapshot isolation even when individual transactions are consistent. Using the classic doctor-on-call scheduling example, they explain how PostgreSQL's default snapshot isolation can allow two overlapping transactions to violate a business rule without ever reading each other's...

Episode 115 of Database Tech with Fexingo. Lucas and Luna drill into multi-tenant database design, using a real SaaS case: a mid-market CRM that hit a noisy-neighbor crisis when one tenant's bulk import saturated disk I/O for everyone. They contrast shared-table vs. schema-per-tenant vs. database-per-tenant architectures, explain why connection pooling and query plan caching break across tenants,...

Row-level security (RLS) is a powerful feature for multi-tenant databases, but it comes with a hidden cost: query performance can degrade significantly if not implemented carefully. In this episode, Lucas and Luna explore how RLS policies interact with query planners, indexing strategies, and connection pooling, using a real-world example of a SaaS platform that saw query latency spike by 300% aft...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into log-structured merge trees (LSM trees) and why they underpin modern write-heavy databases like Cassandra, LevelDB, and RocksDB. They unpack the trade-offs between LSM trees and traditional B-trees, focusing on write amplification, compaction strategies, and real-world performance implications. Using a concrete example of a tim...

Episode 112 of Database Tech with Fexingo tackles a hidden performance killer: query plan caching. Lucas and Luna unpack why reusing cached plans can lead to catastrophic suboptimal execution as data distributions shift, using a real-world case from a mid-size e-commerce company that saw query latency spike 10x after a data ingestion update. They explain the difference between simple and parameter...

In this episode of Database Tech with Fexingo, Lucas and Luna dig into a hidden performance trap in modern databases: JSON schema validation. When you store semi-structured data in columns like PostgreSQL's JSONB or MongoDB, every write triggers a schema check against your defined rules. Lucas breaks down the cost using a real-world example from a logistics company that hit 50-millisecond write la...

In this episode of Database Tech with Fexingo, Lucas and Luna drill into the failure of static connection pool formulas. Using a real-world example from a mid-size e-commerce platform that hit a 503 avalanche during a flash sale, they explain why fixed pool sizes based on max connections or response time are brittle. Lucas introduces the concept of dynamic pool sizing using queue-depth metrics and...

Partition pruning is supposed to speed up queries by skipping irrelevant partitions, but it breaks silently when queries don't match the partition function exactly. Lucas and Luna dig into a real case from a logistics company: a 32-terabyte PostgreSQL time-partitioned table where a date-casting mismatch forced full-table scans on every query. They explain how partition elimination happens under th...

Lucas and Luna explore the overlooked security benefits of database prepared statements. Most engineers treat prepared statements as a performance optimization, but their original design intent was to separate SQL logic from data to prevent injection attacks. The hosts break down a real incident involving a major e-commerce platform where lack of parameterized queries led to a data breach in early...

Lucas and Luna dive into a common but costly database caching mistake: the write-through trap. Using a real-world case from a mid-size e-commerce platform that saw 40% latency spikes after deploying a standard write-through cache, they explain why write-aside caching — where the application explicitly writes to the database and invalidates the cache separately — often yields better consistency and...

Episode 106 of Database Tech with Fexingo dives into a subtle but devastating performance trap: multi-column indexes with the wrong column order. Lucas and Luna walk through a real-world example from an e-commerce database where a well-intentioned index on (status, created_at) caused queries to scan millions of rows instead of hundreds. They explain how B-tree index traversal works, why equality c...