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

Database query routing is harder than it looks. Most systems use a simple round-robin or least-connections strategy, and they fail under skewed traffic patterns. In this episode, Lucas and Luna break down why a consistent hash ring is a better approach, using a real-world example from a mid-size e-commerce platform that switched from a naive router to a hash ring and cut tail latency by 40 percent...

Lucas and Luna unpack a classic database horror story: the time a $400 million e-commerce platform crashed on Black Friday because no one had run VACUUM on its PostgreSQL tables in six months. They explain what a vacuum actually does — reclaiming dead tuples, preventing transaction ID wraparound, and keeping the visibility map healthy — and why treating it as optional maintenance is a ticking time...

Geospatial queries are everywhere—ride-hailing, food delivery, logistics—but the database indexes powering them often fail under real-world coordinate distributions. Lucas and Luna dig into why Z-order curves, the default for many spatial indexes, produce inefficient query rectangles that scan too many tiles, while Hilbert curves preserve locality better for most geospatial workloads. They walk th...

Lucas and Luna explore why traditional stored procedures are being replaced by FaaS-based database functions. They examine a real case where a fintech company cut query latency by 40% and reduced infrastructure costs by moving business logic from the database to serverless functions. The episode breaks down the trade-offs between monolithic stored procedures, lightweight triggers, and cloud-native...

Episode 100 of Database Tech with Fexingo reaches a milestone with a deep dive into read-through caching — why most teams default to write-through caches and miss the bigger performance gains. Lucas and Luna break down the trade-offs using the example of an e-commerce catalog that saw query latency drop from 120 milliseconds to under 4 milliseconds after switching to a read-through pattern with Re...

Episode 99 of Database Tech with Fexingo dives into why naive hash-based sharding collapses under real-world workloads. Lucas and Luna break down a specific incident at a mid-size e-commerce company that saw 40 percent of queries miss the correct shard after a rebalance. They explain why a routing layer — like a lookup table or a consistent-hashing ring — prevents data movement storms, and why the...

Episode 98 of Database Tech with Fexingo unpacks the hidden costs of time travel queries: AS OF in CockroachDB, FOR SYSTEM_TIME in SQL Server, and snapshot reads in cloud databases. Lucas and Luna explore why a simple temporal query that seems like a debugging miracle can silently scan terabytes, blow out IOPS budgets, and crater concurrent write throughput. They walk through a case from a mid-siz...

Lucas and Luna dig into why the classic 'connections = (core_count * 2) + effective_spindle_count' formula fails under modern workloads. They walk through a real-world case at a mid-size ad-tech firm where a PostgreSQL connection pool set to 90 connections caused 40-millisecond p99 latency spikes under burst traffic, and how load-testing with a stepped concurrency model revealed the actual sweet s...

Lucas and Luna drill into a specific failure pattern that derails database infrastructure projects: ignoring cost layers in capacity planning. Using the example of a fintech startup that migrated to a cloud-native distributed SQL database in late 2025, they trace how missing egress pricing, storage I/O costs, and reserved-instance expiry turned a well-scoped six-month project into a budget blowout...

Lucas and Luna dive into a quiet but devastating database problem: query plans that fail because the database has no accurate histogram—or has one so stale it's worse than none at all. They walk through a real scenario: a PostgreSQL 16 query that ran in 12 milliseconds for six months, then suddenly blew up to 47 seconds. The culprit? An ANALYZE job that ran during a bulk DELETE, creating a histogr...

Episode 94 dives into a silent killer in data engineering: audit logs that lose meaning when schemas evolve. Lucas and Luna break down a real incident at a fintech startup where unversioned audit records turned a routine compliance query into a six-week forensic nightmare. They explain why most teams treat audit logs as append-only dumps, how schema drift turns historical records into gibberish, a...

Episode 93 of Database Tech with Fexingo dives into a hidden performance killer: the encryption overhead in database connections. Lucas and Luna examine how TLS handshake latency and cipher negotiation create unexpected latency spikes in high-throughput systems. Using the example of a real-time ad-bidding platform that missed SLA windows by 12 milliseconds — traced to a full TLS re-handshake on ev...

Episode 92 of Database Tech with Fexingo digs into a silent performance killer: foreign key constraints that trigger unexpected cascading lock chains under concurrency. Lucas and Luna walk through a real production scenario from a mid-sized e-commerce platform where a simple `ON DELETE CASCADE` on an orders table caused a 45-minute transaction stall during a flash sale. They explain how referentia...

Episode 91 of Database Tech with Fexingo: SQL, NoSQL, and Data Storage Conversations digs into the hidden costs of soft deletes. Lucas and Luna walk through a real-world case from a mid-2026 e-commerce outage where an `is_deleted` flag caused referential integrity violations, blew up query plans, and silently corrupted financial reports. They explain why soft deletes break unique constraints, how...

Connection pools are supposed to prevent database meltdowns, but they often become the bottleneck themselves. Lucas and Luna unpack why a circuit breaker pattern—borrowed from distributed systems—can save your backend when traffic spikes. They walk through a real scenario: an e-commerce site during a flash sale, where a single slow query cascaded into a complete pool exhaustion. They explain how c...

Lucas and Luna dive into the often-overlooked complexity of routing queries across multi-region database deployments. Using the real-world case of a fast-growing SaaS company that saw query latency spike 300% after expanding to Europe, they explain why a static connection string fails at global scale. Lucas breaks down how a query router—sitting between application and database—can route reads to...

In this episode of Database Tech with Fexingo, Lucas and Luna unpack why hand-rolled aggregate tables often degrade under write-heavy workloads while materialized views with incremental refresh stay fast. They compare a real-world case from a fintech company that migrated from manual nightly rollups to PostgreSQL's materialized views with concurrent refresh, cutting query latency from 12 seconds t...

Database primary keys seem simple—until they bite you. Most developers default to auto-increment integers or standard UUIDs without thinking about the implications. In this episode, Lucas and Luna break down exactly why UUIDv7 is becoming the go-to choice for modern applications. They explain how auto-increment keys create write hotspots in distributed systems, why UUIDv4 wrecks B-tree index perfo...

In this episode of Database Tech with Fexingo, Lucas and Luna tackle a common but often overlooked performance killer: shuffle sort in distributed databases. Using a real case from a mid-sized e-commerce company that saw analytic queries slow from 2 seconds to 45 seconds after migrating from Postgres to a distributed SQL system, Lucas explains how shuffle sort works, why it happens even with simpl...

Episode 85 of Database Tech with Fexingo dives into a deceptively simple problem: why indexing timestamp columns in high-throughput OLTP databases leads to hotspot contention, index bloat, and insert stalls. Lucas and Luna walk through a real-world example from a payment processing platform that saw 40% throughput drop after adding a B-tree index on `created_at`. They explain how monotonically inc...

Lucas and Luna dissect a production outage at a fintech startup when a sudden traffic spike froze their PostgreSQL connection pool. They walk through how PgBouncer handles queuing, why the pool size math often fails under burst, and the specific fix — a hybrid pooling strategy with application-level backpressure — that saved the day. Along the way they cover connection overhead, TCP handshake cost...

Lucas and Luna dive into materialized views: what they are, how they differ from standard views, and why companies like Airbnb and Uber use them to cut query latency. They cover trade-offs like data freshness vs. performance, and how PostgreSQL and Snowflake implement them differently. This episode helps developers decide when to reach for materialized views in 2026. #MaterializedViews #DatabasePe...

Podcast hosts Lucas and Luna explore the limitations of traditional B-tree and hash indexes when applied to vector search for AI workloads. They discuss a production case where a SaaS company saw query latency spike 200x after switching to vector similarity search without changing their indexing strategy. The episode explains why approximate nearest neighbor (ANN) indexes like HNSW and IVF differ...

Row-level security (RLS) in PostgreSQL and other databases is a powerful feature that lets you restrict which rows a user can see based on their role or attributes — but it introduces surprising operational complexity. In this episode, Lucas and Luna explore a real case from a mid-sized fintech company that deployed RLS to isolate customer data across tenancy. Within three months, the engineering...

Even in 2026, database connection pool starvation remains a top production issue. Lucas and Luna revisit why connection pool exhaustion still occurs despite years of best practices, using a real-world example from a mid-sized e-commerce platform that saw cascading failures during a flash sale. They explain the two most common root causes: too-small pools and long-running queries holding connection...