All Episodes
Database Tech with Fexingo: SQL, NoSQL, and Data Storage Conversations — 183 episodes · page 1 of 2
How Database Schema Evolution Shapes Tech Strategy
The Silent Killer Of Database Performance
How Database Latency Costs Companies Millions
Why Your Database Is Leaking Data Through Silent Failures
How Database Schema Drift Erodes Engineering Velocity
How Data Lineage Prevents Compliance Nightmares
How Database Indexes Drift And Cost You Money
How Database Indexes Actually Speed Up Queries
Why Your Database Is Leaking Money on Unused Indexes
Why Your Database Queries Are Slow
Why Your Database Sucks at Real Time Data
How Data Mesh Decentralizes Enterprise Tech
How Data Contracts Prevent Broken Pipelines
Why Your Database Chokes on Simple Queries
Why Your Database Is Wasting Money on Indexes
How Database Partitioning Saves Engineering Teams
The Hidden Cost of Data Modeling Mistakes
How Vector Databases Are Changing Search
How Database Caching Breaks Consistency
The Hidden Cost of Database Storage Efficiency
The Cost of Waiting for Database Consistency
The Real Cost of Database Vendor Lock-In
Why Your Database Chokes on Simple Queries
How Data Gravity Shifts Cloud Economics
How Data Normalization Prevents Billion-Dollar Glitches
How Database Locks Kill Your App Speed
The Hidden Cost of Database Consistency Models
How Database Sharding Scales Without Breaking
How Databases Handle Data Decay and Retention
How Database Schema Evolution Saves Engineering Teams
How Data Lineage Transforms Audit Compliance
How Database Connection Pools Save Systems
How Distributed Databases Handle Consistency Without Killing Speed
How Databases Handle Data Decay and Retention
How Database Caching Transforms App Speed
How Databases Handle the Midnight Traffic Spike
Why Your Database Is Slow Despite Perfect Indexes
How Database Partitioning Saves Cloud Costs
How Database Indexes Create Write Amplification Problems
The Silent Killer of Database Performance
How Database Indexes Create Write Amplification Problems
How Database Partitioning Saves Billions in Cloud Costs
How Database Column Stores Crushed Row Storage
How Database Row Formats Save Cloud Costs
How Database Partitioning Saves Billions in Cloud Costs
Why Database Indexes Create Write Amplification Problems
How Database Partitioning Saves Billions in Cloud Costs
Why Database Query Optimizers Underestimate Joins
Why Database Compaction Can Stall Under Write Load
Why Database Query Planning Uses Cost Models
Why Database Sharding Needs a Routing Layer
Why Database Transactions Use Two-Phase Locking
How Database Replication Lags Under Partitioning
Why Database Query Planning Uses Cost Models
Why Database Connection Timeouts Need Jitter
Why Database Backups Need Incremental Strategy
Why Database Caching Layers Need Write-Through Strategies
Why Database Snapshot Isolation Is Not Serializable
Why Database Storage Engines Use LSM Trees
Why Database WAL Is the Unsung Hero of Durability
Why Database Time Series Storage Uses Chunked Archives
Why Database Migrations Need Expansion and Contraction
Why Database Vectors Need HNSW Indexes
Why Database Connections Need Multiplexing Not Pools
Why Database Time Series Compression Uses Delta and Gorilla Encoding
Why Database Query Caches Fail Under Write Workloads
Why Database Denormalization Can Beat Joins for Hot Paths
Why Database Triggers Can Cause More Harm Than Good
Why Database Connection Pooling Breaks Under Burst Load
Why Database Indexes Use Adaptive Radix Trees
Why Database Statistics Need Histograms for Query Plans
Why Database Query Plans Go Wrong Without Histograms
Database Indexing with Sparse Indexes and B-Trees
Why Database Sharding Needs a Consistent Hash Ring
Why False Positives in Database Bloom Filters Are Hidden Cost
Why Database MVCC Needs Visibility Rules Not Locks
Why Database Replication Lag Breaks Read-Your-Writes Consistency
Why Database Autoincrement Keys Fail at Global Scale
Why Database Compression Uses Dictionary Encoding Not Run-Length
Why Database Recovery Needs ARIES Protocol
Why Database Serializable Snapshot Isolation Prevents Write Skew
Why Database Upsert Needs Merge Not Separate Insert or Update
Why Database Caching Needs a Write-Through Strategy
Why Write-Ahead Logging Is Critical for Database Durability
Why Database Partition Pruning Cuts Query Time Dramatically
Why Database Merge Joins Beat Hash Joins for Sorted Data
Why SQL Window Functions Outperform Self-Joins
Why Time-Series Data Needs Downsampling Not Raw Storage
Why Database Schema Changes Need Online Migration Not Downtime
Why Database Bloom Filters Defeat Expensive Disk Seeks
Why Database Cursor Fetching Needs Pagination Not Streaming
Why Database Deadlocks Need Wait-Die and Wound-Wait Schemes
Why Database Hybrid Transactional-Analytical Processing Matters
Why Database Query Routing Needs Read-Write Splitting
Why Database Sharding Fails Without a Consistent Hash Ring
Why Database Connection Timeouts Need Adaptive Retry Logic
Why Database Change Data Capture Needs Exactly-Once Semantics
Why Database Replication Needs Quorum Not Just Async
Why Database Vector Indexes Need Hierarchical Navigable Small Worlds
Why Database Compression Needs Dictionary Encoding Not Just Run-Length