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

Episode 54 of Database Tech with Fexingo dives into cursor-based pagination — a technique that avoids the performance pitfalls of traditional offset/limit queries. Lucas explains how offset forces the database to scan and discard rows, while cursor pagination uses a unique key to jump directly to the next page. Luna brings up a real-world case: a SaaS company that reduced API response times from 8...

In episode 53 of Database Tech with Fexingo, Lucas and Luna dive into a silent concurrency killer: database lock contention. Using a real-world example of an e-commerce platform's inventory system crashing under Black Friday load, they explain the difference between optimistic and pessimistic locking, how lock escalation turns row-level locks into table locks, and why even read queries can block u...

Episode 52 of Database Tech with Fexingo explores the hidden cost of schema changes in production databases. Lucas and Luna break down a real-world case: how a major e-commerce platform's single ALTER TABLE triggered a 47-minute outage during Black Friday 2025. They discuss schema versioning tools like Flyway and Liquibase, the concept of backward-compatible migrations, and why rolling out changes...

Lucas and Luna dive into the hidden performance cost of database triggers, using a real-world example from a mid-size e-commerce company that lost 40% of its checkout throughput due to a single poorly designed trigger. They explain why triggers break your ability to reason about latency, how they create hidden bottlenecks under write-heavy workloads, and what to use instead—like application-layer...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the practical realities of database sharding in 2026. They use the example of a fast-growing e-commerce platform that split its order history across ten shards only to hit a cross-shard join nightmare. Lucas explains the difference between horizontal sharding and vertical partitioning, and why choosing the wrong shard key (use...

Lucas and Luna dive into the mechanics and hidden costs of database connection pool starvation — a failure mode that can take down a production system in seconds. Using the real-world example of a mid-sized SaaS company that saw latency spike from 12ms to 22 seconds after a routine code deployment, they explain why connection pools are not a 'set and forget' resource. Lucas walks through the math:...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the hidden chaos of time zone handling in databases. Using the real-world example of a popular booking platform that lost millions in revenue due to incorrect time zone conversions, they explore why most developers underestimate the complexity. They discuss the difference between TIMESTAMP WITH TIME ZONE and TIMESTAMP WITHOUT...

Lucas and Luna dive into the hidden inefficiency of row-oriented storage for modern analytics workloads. They explain how columnar storage flips the script by storing data by column instead of row, dramatically reducing I/O and improving query speed. The episode uses a concrete example: a 50-column sales table where a typical dashboard query touches only 5 columns. Lucas walks through what happens...

Lucas and Luna dive into a specific failure pattern that takes down production databases: the thundering herd problem caused by naive retry logic. They walk through a real-world example of a payment processing system where every failed connection retried immediately, and how switching to exponential backoff with jitter prevented cascading outages. They explain the math behind the backoff, why addi...

Episode 45 of Database Tech with Fexingo digs into a silent performance killer: how NULL values in your database columns can lead to full table scans, bloated indexes, and query plans that ignore your best indexes. Lucas and Luna walk through a real-world example from an e-commerce order database, showing how three-valued logic (TRUE, FALSE, UNKNOWN) confuses the query optimizer. They explain why...

Episode 44 of Database Tech with Fexingo: Lucas and Luna dig into a subtle performance killer in partitioned databases — partition pruning that silently doesn't prune. They walk through how a real-world e-commerce system ran full-table scans on 200 partitions because the WHERE clause used a function-wrapped partition key. They explain how databases like PostgreSQL and MySQL handle partition elimin...

Episode 43 of Database Tech with Fexingo digs into column-level compression — a technique that reduced one company's storage bill by 70 percent and sped up analytic queries by 40 percent. Lucas and Luna break down how compression works under the hood, why it's not a one-size-fits-all solution, and which database systems support it natively. They also discuss trade-offs: decompression overhead for...

In episode 42 of Database Tech with Fexingo, Lucas and Luna dive into the fine-tuning of database connection pool sizes, a topic that remains critical for performance in 2026. They explore the classic formula for pool sizing, explain why bigger pools don't always mean better performance, and walk through a real-world example: a Postgres application that saw a 40% latency reduction after cutting po...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into materialized views—a powerful but often overlooked database feature. They explain how materialized views differ from regular views by physically storing query results, dramatically improving read performance for complex aggregations. Using the example of a real-time analytics dashboard, they illustrate when materialized views...

Episode 40 of Database Tech with Fexingo dives into the overlooked risks of database backups under concurrent workloads. Lucas explains how PostgreSQL's `pg_dump` can cause hidden performance degradation when run during peak hours, citing a real-world case where a fintech platform saw query latency spike 300% due to backup-induced lock contention. Luna brings up MySQL's Percona XtraBackup and the...

In this episode, Lucas and Luna dive into the silent killer of database performance: unoptimized queries that go unnoticed until the database is under real load. They examine a real-world case where a company's PostgreSQL instance ground to a halt because a single query was scanning millions of rows every five seconds — and how enabling pg_stat_statements and analyzing query patterns turned a 30-s...

In Episode 38 of Database Tech with Fexingo, Lucas and Luna explore the emerging concept of connectionless database architectures. Using CockroachDB and Google Cloud Spanner as concrete examples, they explain how eliminating persistent TCP connections can reduce latency, improve scalability, and simplify connection management for modern distributed systems. The hosts discuss the HTTP/gRPC-based re...

In this episode of Database Tech with Fexingo, Lucas and Luna explore why stored procedures—once considered legacy—are seeing a resurgence in modern cloud databases. They break down a real-world case from a mid-sized e-commerce company that cut query latency by 40 percent by moving critical order-processing logic into stored procedures. The discussion covers when to use them, the trade-offs with a...

Lucas and Luna explore a counterintuitive database performance issue: indexes that actually slow queries down. They examine how B-tree index depth grows with data volume, turning fast lookups into multi-level tree traversals. The discussion uses a concrete example of a 10-million-row table on PostgreSQL and shows how a poorly chosen composite index on an e-commerce orders table caused query times...

Lucas and Luna explore why database connection latency can suddenly spike from 2 milliseconds to over 200 milliseconds under heavy load, even when the database itself isn't saturated. They examine a real-world case from a mid-sized e-commerce platform where connection establishment overhead — TCP handshakes, TLS negotiation, authentication — became the bottleneck after a routine deployment. Lucas...

On this episode of Database Tech with Fexingo, Lucas and Luna dig into why caching — a go-to performance fix — can actually harm your database under write-heavy workloads. They break down the invalidation problem using a concrete example: a social media platform tracking daily active users. Lucas explains how a naive time-to-live cache can return stale data for hours, while Luna pushes back on the...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the hidden costs of database timeouts—specifically, why the default timeout values in most application frameworks are dangerously high. Using a real-world case from a mid-sized e-commerce company that saw a 40% drop in checkout completion after a traffic spike, they explain how timeouts compound under load, how to calculate th...

Episode 32 of Database Tech with Fexingo. Lucas and Luna uncover a subtle but dangerous database vulnerability: security views that accidentally expose sensitive columns like passwords or SSNs through simple tricks like casting to text or selecting via star. Drawing on a real 2023 incident where a Fortune 500 company leaked 50,000 customer records through a poorly designed view, they explain how P...

Episode 31 of Database Tech with Fexingo dives into connection validation — the silent killer of production databases. Lucas and Luna explore why a PostgreSQL pool at a mid-sized e-commerce company crashed during Black Friday, how a single 'SELECT 1' health check could have prevented it, and why many teams skip validation until it's too late. They break down the difference between idle-in-transact...

Lucas and Luna dig into a topic that most developers treat as a checkbox: connection encryption between applications and databases. Using the example of a mid-size fintech that discovered unencrypted PostgreSQL traffic on its internal network, they explain why TLS between app and database is not just a compliance requirement but a real security boundary. They cover the difference between encryptio...