Series / Databases
Retrieval architecture across pgvector, hybrid search, embeddings, GPU databases, and the operational boundaries around AI database access.
Engineers building RAG pipelines, semantic search, or recommendation systems who need to make real architectural decisions — index type, embedding model, hybrid vs pure vector, and when to move off Postgres.
You know what an embedding is and have at least experimented with semantic search. Familiarity with PostgreSQL is helpful.
How CPU, GPU, and TPU architectures differ in ways that matter for databases and AI workloads — and which compute class to reach for when adding vector search, embedding generation, or GPU-accelerated analytics.
How CPU, GPU, and TPU architectures differ in ways that matter for databases and AI workloads — and which compute class to reach for when adding vector search, embedding generation, or GPU-accelerated analytics.
How pgvector adds vector storage and similarity search to PostgreSQL, what the three distance operators do, and the index you must create before you hit 100K rows.
A DBA-friendly explanation of SIMD and SIMT using query execution, vectorized processing, and GPU mental models instead of hardware jargon.
A production-oriented decision matrix for choosing pgvector, OpenSearch, Qdrant, or Weaviate by workload shape, filters, hybrid search, operations, cost, tenancy, and recovery.
Why production search systems should combine BM25, vector retrieval, filters, fusion, ranking, and reranking before relying on LLM answers.
A practical, DBA-friendly explanation of why modern analytical databases are increasingly using GPUs for scans, joins, aggregations, and AI-adjacent workloads.
When a Postgres-first RAG design with pgvector is simpler, safer, and easier to operate than adding a separate vector database.
A database-first decision guide for using PostgreSQL full-text search and pgvector before adding a search engine or vector database.
A structured runbook for identifying which cost dimension is driving your AWS RDS or Aurora bill before making any changes.
A DBA-friendly walkthrough of how modern GPU databases execute large analytical SQL queries using columnar storage, parallel scans, and GPU aggregation.
Why approximate pgvector searches can under-return rows after SQL filters, and how to tune filtered HNSW with ef_search, partial indexes, partitioning, and iterative scans.
A DBA-friendly explanation of how vector search works, why GPUs help, and where vector retrieval fits inside modern database and AI systems.
A practical DBA guide to pgvector HNSW and IVFFlat tradeoffs across build time, memory, recall, writes, maintenance, and query tuning.
A production framework for adding agents only when users need planning, tool calls, validation, retries, and governed actions.
When OpenSearch is the right vector-search platform because keyword search, hybrid retrieval, relevance debugging, and search operations already matter.
A production decision guide for GraphRAG, entity graphs, community summaries, relationship reasoning, and where graph retrieval is overkill.
A production architecture for product catalog hybrid search with OpenSearch, combining BM25, vector retrieval, filters, shard design, reranking, and relevance debugging.
An Aurora-native investigation method for correlating per-instance database load, distributed storage, reader lag, endpoint behavior, and failover readiness with LLM assistance.
A DBA and platform-engineering view of Qdrant for production RAG, covering collections, points, payloads, filters, dense and sparse retrieval, snapshots, scaling, and limits.
Why dense plus sparse retrieval in Qdrant needs careful fusion, score normalization, candidate sizing, and reranking to work in production RAG.
How Weaviate named vectors let one object carry title, body, image, code, or support-ticket embeddings, and what that means for schema evolution and backfills.
A database engineer's guide to Weaviate hybrid search, including collections, objects, BM25, vectors, filters, tenancy, schema design, and operational tradeoffs.
An Aurora PostgreSQL incident workflow for separating writer pressure, shared-storage activity, local temporary I/O, WAL retention, replica lag, and application recovery after failover.
A DBA watchlist for running pgvector on Aurora PostgreSQL, covering extension support, memory, I/O, WAL, replicas, failover, backups, parameters, and cost.
Why pgvector changes backup and restore planning for RAG systems, including vector column size, index rebuilds, embedding reproducibility, source-of-truth design, and DR runbooks.
How large embedding backfills stress PostgreSQL through batch size, WAL growth, checkpoints, autovacuum lag, bloat, index timing, throttling, and rollback planning.
How to design tenant-scoped pgvector search with tenant filters, partial indexes, list or hash partitioning, filtered HNSW behavior, query plans, operational limits, and isolation tradeoffs.
An Oracle incident workflow for proving whether blocking, commit processing, RAC block transfer, storage, or cloud infrastructure—not SQL efficiency—caused the slowdown.
How DBAs should read PostgreSQL EXPLAIN plans for pgvector queries, including index scans, sequential scans, ORDER BY distance, LIMIT, filters, iterative scans, cost estimates, and plan surprises.
How to combine PostgreSQL full-text search and pgvector for low-cost hybrid retrieval, including tsvector, ranking, semantic search, fusion, filters, observability, and when to outgrow it.
An infrastructure view of OpenSearch vector search, covering k-NN fields, HNSW, shards, segments, refresh, merges, memory, node sizing, and operational gotchas.
The tradeoffs of Amazon OpenSearch Service for vector search, including managed operations, scaling, instance choice, storage, memory, transfer, snapshots, and index design cost.
A production guide to OpenSearch hybrid retrieval with BM25, vector k-NN, metadata filters, score fusion, reranking, relevance debugging, and observability.
OpenSearch vector search failure modes for operators, including shard count, hot shards, tenant skew, memory pressure, recall degradation, slow merges, filters, and recovery.
A safe migration path from keyword search to semantic or hybrid OpenSearch retrieval using dual indexing, embeddings, backfill, relevance evaluation, A/B testing, fallback, rollback, and cutover.
A systems engineering analysis of vector search performance: navigating the fundamental tradeoff between Recall@K, query latency, index memory footprint, quantization, and filtered search.
A production triage guide for multi-stage vector search: isolating query embedding latency, HNSW graph degradation, hybrid BM25 fusion skew, and cross-encoder reranking bottlenecks.
An end-to-end performance engineering guide for production RAG: optimizing query embedding, hybrid retrieval, reranking, prompt caching, time-to-first-token, and cost per request.
How tree-based retrieval can improve DB runbooks, schema docs, and incident knowledge over chunked vector search.
A breakdown of Fareed Khan's open-source RAG pipeline for large document corpora: hybrid retrieval, claim-level faithfulness verification, and calibrated abstention — with the real numbers, and the honest limits of the 10M-vector scale claim.
Why PostgreSQL and MySQL use B-trees while Cassandra and RocksDB use LSM trees — the read/write tradeoff that determines which storage engine fits your workload.
Isolating the OCI Autonomous Transaction Processing write path from catalog and analytics load using GoldenGate replication and Object Storage offloading.
Session cache versus durable cart: the recovery semantics that determine data survival across session loss, browser closure, and checkout failure.
Cloud cost triage across compute, storage, data transfer, logs, and managed services — a repeatable workflow for finding runaway spend before the bill arrives.
An architectural comparison of Amazon RDS for MySQL 8.4 against Aurora MySQL, focusing on write path physics, EBS bottlenecks, and distributed storage IOPS.
A deep dive into how MySQL, PostgreSQL, and Oracle fundamentally differ in physical storage organization, index architecture, and why Uber famously migrated from Postgres to MySQL.
Why a PostgreSQL double write buffer prototype failed despite compiling, and what it reveals about AI-assisted systems design.
The second wave of March 2026 breakouts: an agent that learns from every conversation, a Rust vector index that outperforms FAISS at a fraction of the memory, and a Kubernetes-native agent control plane.