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

Lucas and Luna discuss a painful production outage at a fintech company caused by a database schema migration that ran before the application code was ready. They explain how feature flags can decouple deployment from release, the risks of online DDL tools in high-traffic systems, and why many teams still treat migrations as an afterthought. Specific numbers: 47-minute write lock, 12 terabytes of...

Lucas and Luna explore why a growing number of organizations are adopting multi-model databases—systems that natively support relational, document, graph, and key-value workloads in a single engine. They examine the driving forces: the rise of polyglot persistence fatigue, the cost savings from eliminating multiple database stacks, and the practical trade-offs in query performance and operational...

Lucas and Luna explore why database caching layers are essential for preventing read throughput collapse under heavy load, using a real-world example from a mid-sized e-commerce platform that saw query latency spike from 12ms to over 2 seconds during a flash sale. They break down caching strategies including write-through, write-behind, and cache-aside patterns, and explain how a poorly configured...

Change Data Capture (CDC) pipelines are the backbone of modern real-time data architectures, but they often fail in production when event volume spikes or schema changes silently. Lucas and Luna walk through a real-world case from a mid-2026 fintech outage: a CDC pipeline that missed 12% of transactions during a flash sale because of unbounded log retention and missing idempotency keys. They expla...

Lucas and Luna dig into a subtle database pitfall: indexing JSON fields inside Postgres and MySQL. They walk through a real production case where a developer added a GIN index on a JSONB column, only to find query times actually increased for certain lookup patterns. The problem: JSON indexes don't behave like simple B-tree indexes; they store the entire JSON structure, and queries that don't use...

Sharding is supposed to make databases infinitely scalable, but choosing the wrong shard key can destroy performance. Lucas and Luna dig into a real case: a mid-size SaaS company that sharded their user table by customer ID, only to see one shard handle 90% of the traffic because their biggest client's users logged in at the same time. They walk through how hash-based keys, composite keys, and loo...

Lucas and Luna dive into why database columnar storage formats like Parquet and ORC have become essential for analytic workloads, especially in cloud environments. They explore how columnar storage differs from row-based storage, using concrete examples from Amazon Redshift and Google BigQuery. The episode walks through compression benefits, predicate pushdown, and how choosing the right format ca...

Episode 72 of Database Tech with Fexingo dives into the messy reality of transaction isolation levels in modern databases. Lucas and Luna unpack a real incident where a Postgres deployment hit serialization anomalies because the team assumed READ COMMITTED was safe for a financial reconciliation job. They walk through what each isolation level actually guarantees—READ UNCOMMITTED, READ COMMITTED,...

Lucas and Luna dig into a frustrating reality: database query execution plans — the diagrams engineers use to understand why a query is slow — can be misleading or outright wrong. They walk through a real case from a mid-size SaaS company that was blind to a bad query plan for months, costing thousands in wasted compute. They explain the key gap between estimated vs. actual row counts, why outdate...

Lucas and Luna dive into database virtualization — a technique that decouples compute from storage, letting you consolidate databases onto shared storage without rewriting a single query. Lucas explains how tools like the open-source Vitess and commercial proxies let teams reduce cloud compute bills by 40-60% by pooling database instances behind a virtual layer. Luna pushes back on the complexity...

Lucas and Luna investigate why database connection pool starvation remains a top production issue in 2026. They trace a real-world incident at a mid-size e-commerce company where a 50-node microservice architecture brought down checkout during a flash sale. Lucas explains the math: if each node opens 10 connections but the pool maxes at 200, a slow query on one service can cascade and lock everyon...

In this episode of Database Tech with Fexingo, Lucas and Luna dive into the often-overlooked layer beneath your queries: the storage engine. Using the real-world case of a mid-size e-commerce company that switched from InnoDB to MyRocks for write-heavy workloads, they explain how storage engines like B-tree vs LSM-tree affect insert throughput, compression, and read latency. Lucas breaks down the...

Episode 67 of Database Tech with Fexingo dives into the persistent problem of database connection pool starvation. Lucas explains why even modern applications with connection pools like HikariCP and PgBouncer can still hit starvation under high concurrency, using a real-world example from a fintech startup that saw transactions queue up during peak hours. Luna asks about the difference between poo...

Lucas and Luna dig into a production incident at a mid-size e-commerce company where connection pool starvation brought down their checkout service on a Cyber Monday. They walk through what a connection pool is, how starvation happens when pool size is misconfigured or transactions are too slow, and why monitoring connection wait times is more important than the pool max. They also cover how conne...

In this episode, Lucas and Luna dig into why database connection pool starvation remains a top-five production outage cause, even in 2026. They walk through a real case: a mid-sized e-commerce platform whose checkout latency spiked to 30 seconds during a flash sale — traced back to a pool max size of 10 connections. Lucas explains the math behind Little's Law for pool sizing, why default HikariCP...

Episode 64 of Database Tech with Fexingo dives into a trap that catches even senior engineers: indexing JSON fields in PostgreSQL and MySQL. Lucas and Luna dissect a real incident from a mid-size e-commerce company whose product search slowed to a crawl after they indexed a JSONB column with a GIN index. They explain why JSON indexes look great on paper but explode in size and cost under write-hea...

Episode 63 of Database Tech with Fexingo dives into a rarely discussed but critical topic: backup verification. Lucas and Luna explore why a leading fintech company lost 12 hours of transaction data despite having daily backups. They break down the difference between backup creation and backup validation, using the 2025 case of a major payment processor that discovered its six-month-old backups we...

In this episode, Lucas and Luna dive into the often-overlooked art of database connection pool sizing. They explain why the classic formula of `connections = (core_count * 2) + effective_spindle_count` is outdated in the era of cloud databases and high-concurrency workloads. Using a real-world case study from a mid-size e-commerce platform that reduced query latency by 40% simply by tuning its poo...

When Luma Retail expanded into Japanese markets in early 2026, their PostgreSQL search queries started returning wrong results. The culprit wasn't code—it was collation. Lucas and Luna break down how database collation settings silently corrupt string comparison, why UTF-8 alone isn't enough, and how one e-commerce company fixed a 12% drop in search accuracy by switching from default 'en_US.UTF-8'...

Episode 60 of Database Tech with Fexingo dives into a quiet but critical skill: knowing when to override the database query optimizer with hints, and when to let it do its job. Lucas and Luna dissect a real-world case from a mid-size e-commerce company whose PostgreSQL queries were slowing down because of a misguided index hint. They explain how modern optimizers like those in PostgreSQL 17 and SQ...

Episode 59 of Database Tech with Fexingo tackles the growing challenge of time-series data in modern databases. Lucas and Luna explore why most default partitioning strategies fail for high-ingestion rate workloads, using a detailed example of a real-time IoT sensor system processing 10,000 writes per second. They discuss the hidden cost of partition splits, the importance of pre-creating partitio...

Lucas and Luna explore how HTAP is reshaping database architecture, using the example of a mid-sized e-commerce company that cut query latency by 60% by merging transactional and analytical workloads into a single system. They break down the technical trade-offs, real-world performance gains, and why 2026 is the year HTAP hits mainstream adoption. #HTAP #HybridTransactionalAnalyticalProcessing #Da...

Episode 57 of Database Tech with Fexingo dives into read replicas — what they are, why they matter, and the common mistakes that undermine them. Lucas and Luna walk through a concrete example: a mid-size e-commerce platform handling 200,000 queries per minute, where a single primary database buckles under read traffic. They explain how adding two read replicas in different availability zones cut q...

Database caching can save millions of dollars in compute costs—or cause catastrophic failures if designed poorly. Lucas and Luna dive into the infamous 2020 Fastly CDN outage, where a single caching misconfiguration took down major websites for an hour, and contrast it with the layered caching strategies used by companies like Cloudflare and Netflix. They explain the difference between write-throu...

In this episode of Database Tech with Fexingo, Lucas and Luna explore why refactoring database connections — from inefficient pooling and unnecessary opens to mismatched timeouts — can save companies millions in infrastructure costs. They break down a real-world case where a mid-sized tech firm reduced cloud database spend by 40% by auditing and restructuring their connection layer. The conversati...