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

Lucas and Luna explore how index bloat silently degrades database performance, turning fast queries into sluggish experiences. They examine the mechanics of write amplification, the hidden costs of maintaining too many indexes, and practical strategies for monitoring and pruning unused or redundant indices in modern cloud environments. This episode offers concrete advice for engineers managing hig...

Lucas and Luna dissect the hidden cost of fast reads: write amplification. They examine how maintaining secondary indexes forces databases to rewrite data multiple times per transaction, slowing down high-throughput systems. Using a concrete example from a major e-commerce platform, they explain why dropping an index can sometimes double write speed, and what engineering teams do when read perform...

This episode explores the hidden economics of database partitioning, using a specific case study from a major fintech platform that reduced its cloud storage bill by forty percent simply by restructuring how it archived old transaction records. Lucas and Luna break down why keeping hot data on expensive SSDs while moving cold data to cheaper object storage is not just a technical choice but a P&L...

We dive into the structural shift from row-oriented to column-oriented database storage, using ClickHouse as the primary case study. While traditional databases like PostgreSQL store data row-by-row for transactional integrity, column stores like ClickHouse group identical fields together on disk. This architectural choice transforms analytical queries from seconds into milliseconds by eliminating...

This week we look at how changing a database's internal row format from variable-length to fixed-length encoding can cut storage bills by forty percent. We use a specific e-commerce archive case to show why this matters. The hosts discuss the trade-offs between CPU cycles and disk I/O, and why modern cloud providers are pushing columnar stores for analytics workloads. #DatabaseEngineering #CloudCo...

We break down why horizontal partitioning is the silent profit driver for high-scale data platforms. Using a concrete example of how splitting user activity logs by date and region reduces storage costs by over sixty percent, we explore the trade-offs between query complexity and infrastructure savings. Lucas walks through the mechanics of cold versus hot data tiering, while Luna challenges the op...

Most engineers assume adding an index makes queries faster without cost. This episode breaks down write amplification, where every insert triggers multiple disk writes to maintain index structures. We examine how this overhead impacts throughput in high-traffic systems and why your choice of storage engine matters more than you think when designing for write-heavy workloads. #DatabaseEngineering #...

Most companies overpay for cloud database storage by failing to understand lifecycle management. We break down the specific mechanics of hot, warm, and cold data partitioning using a real-world e-commerce example where moving six months of order history to object storage cut monthly bills by forty percent. Lucas and Luna explore how to design partition keys that respect query patterns while minimi...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into a classic failure mode of query optimizers: join cardinality misestimation. Using the example of a customer analytics dashboard, they explain why optimizers often underestimate join selectivity, leading to catastrophic query plans. They explore how statistics, histograms, and correlation assumptions break down, and discuss pra...

On this episode of Database Tech with Fexingo, Lucas and Luna dig into a database problem that quietly wrecks performance: compaction. When a storage engine based on LSM trees merges sorted runs in the background, it can suddenly steal CPU and disk bandwidth, causing latency spikes and write stalls. The hosts explain why compaction is necessary, how it can go wrong, and what engineers can do to ke...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the hidden complexity of database query planning. They explore how modern databases decide between a sequential scan and an index scan, why the planner's cost model matters more than raw speed, and how a single bad cardinality estimate can turn a two-millisecond query into a two-second disaster. Using a concrete example of a u...

Most teams treat sharding as a storage problem, but the real bottleneck is the routing layer that decides which shard handles each query. In this episode, Lucas and Luna break down why a naive hash on user ID breaks as soon as you add nodes, why consistent hashing became the default, and how Netflix's move to active-active sharding forced them to rethink routing entirely. They also look at Vitess,...

In this episode, Lucas and Luna dig into two-phase locking—the protocol that keeps database transactions from colliding. They use the example of a bank transfer, where a debit and a credit must happen atomically, to show why locking is more than just 'preventing overwrites.' The conversation walks through the two phases: growing, where locks are only acquired, and shrinking, where locks are only r...

In Episode 167 of Database Tech with Fexingo, Lucas and Luna drill into a specific failure mode: when a database partition splits, replication lag can spike because the leader now has to ship more data per partition. They walk through a real pattern seen in distributed systems like Cassandra and MySQL cluster, where partition splits lead to a burst of writes and a lag spike that can cause stale re...

In this episode of Database Tech with Fexingo, Lucas and Luna dig into the often-overlooked cost model that sits at the heart of every query optimizer. They explain how databases estimate the cost of different query plans, why those estimates can be wildly wrong, and what happens when they are. Using the example of a simple join gone slow, they walk through the key components: table cardinality, s...

In episode 165 of Database Tech with Fexingo, Lucas and Luna dive into the hidden costs of client-side database connection timeouts and why adding random jitter can prevent cascading failures. They use the classic thundering herd scenario—a retail site's Black Friday surge—to explain how fixed timeouts cause synchronized retry storms, and how jitter breaks that synchronization. The hosts trace the...

In episode 164 of Database Tech with Fexingo, Lucas and Luna dive into the hidden complexities of database backup strategies, focusing on the shift from full backups to incremental and differential approaches. Using the example of a mid-sized e-commerce platform recovering from a ransomware attack, they explain how backup frequency, recovery time objectives, and storage costs interact. They also e...

In this episode of Database Tech with Fexingo, Lucas and Luna break down why write-back caching—the tempting shortcut that promises instant performance—can quietly corrupt your data. They walk through a real-world example from an e-commerce inventory system where a sudden crash turned stock levels into fiction, and explain how write-through and write-around strategies trade a little latency for a...

In this episode, Lucas and Luna unpack the difference between snapshot isolation and true serializability in database transactions. Using the classic write-skew example with a hospital on-call schedule, they explain why snapshot isolation—the default in PostgreSQL and many cloud databases—can violate the guarantees developers assume they're getting. They walk through how PostgreSQL uses SSI (seria...

Episode 161 of Database Tech with Fexingo breaks down the LSM tree, the storage structure behind many modern databases. Lucas and Luna explain why write-heavy workloads struggle with traditional B-trees, how LSM trees turn random writes into sequential ones, and the price they pay in read performance. Using the example of a ride-hailing company's trip log, they walk through memtables, SSTables, co...

In this episode of Database Tech with Fexingo, Lucas and Luna unpack the write-ahead log (WAL) — the unsung hero of database durability. They explain why every modern database, from PostgreSQL to SQLite, relies on WAL to prevent data loss during crashes, how it works under the hood, and why it's not a silver bullet. Using a concrete example of a bank transfer and a sudden power outage, they illust...

In this episode of Database Tech with Fexingo, Lucas and Luna dig into the design of time-series databases and the chunked archive pattern that underpins systems like InfluxDB, Prometheus, and TimescaleDB. They explain why a flat table of timestamped rows performs poorly at scale, how chunking data by time interval improves write throughput and query speed, and how compression and retention polici...

Database schema changes are inevitable, but altering a live table with millions of rows can lock it for hours and take down your service. In this episode, Lucas and Luna dive into the expand-and-contract pattern, the technique that lets teams change schemas without downtime by running dual writes, backfilling, and switching reads in phases. They walk through a real-world example: a checkout table...

In this episode of Database Tech with Fexingo, Lucas and Luna unpack Hierarchical Navigable Small World (HNSW) indexes—the engine behind modern vector search. They start with a real-world latency problem at a music recommendation startup, then explain why brute-force similarity search collapses at scale. With a whiteboard-style breakdown, they reveal how HNSW builds multi-layer graphs to navigate...

Connection pooling is the standard fix for database connection overhead, but under burst load, pools themselves become the bottleneck. In this episode, Lucas and Luna dig into multiplexing—why streaming a single connection across many requests can outperform a pool, how PostgreSQL and MySQL handle it differently, and what happens when a bank's payment service hit a connection ceiling on a Black Fr...