A working engineer's guide to database indexes: when each index type (B-tree, hash, GiST, SP-GiST, BRIN, GIN, columnstore) is the right answer, what an index actually costs you on every write, and how the query planner decides whether to use one at all.
Data & Databases
-
Database Indexes Explained -
Distributed SQL: CockroachDB, TiDB, and YugabyteDB NewSQL that survives a node dying while still speaking SQL. How Raft-replicated ranges deliver horizontal scale with strong consistency, the Google Spanner lineage the whole category descends from, multi-region survival goals and the latency tax they impose, online schema changes that don't lock the table, an honest head-to-head of CockroachDB, TiDB, and YugabyteDB — and the unglamorous truth that boring single-node Postgres still wins for most applications.
-
Graph Databases with Neo4j The property-graph model explained from first principles: nodes, relationships, and properties; Cypher queries for real traversal problems; why index-free adjacency beats recursive SQL CTEs for deep graph walks; fraud detection, recommendations, and knowledge graphs as concrete production use cases; Neo4j clustering and causal consistency; and an honest accounting of when adding a graph database is the wrong call.
-
MongoDB Done Right The document database past the hype: the embed-versus-reference decision that makes or breaks a schema, denormalization that does not rot, when MongoDB genuinely beats Postgres JSONB and when it does not, the aggregation pipeline, indexing and the working-set rule, replica sets and sharding, the read/write-concern consistency knobs, and the operational footguns — unbounded arrays and the 16 MB BSON limit — that sink naive designs.
-
Polars: The DataFrame That Replaced pandas How Polars — a Rust-backed, Arrow-native DataFrame library — achieves real multi-core performance, a query optimizer, and streaming execution that pandas structurally cannot match, and how to migrate to it without losing your mind.
-
Ray: Distributed Python Without the Pain A deep technical look at Ray's core primitives, scheduling model, high-level ML libraries, KubeRay on Kubernetes, and honest trade-offs versus Dask and Spark.
-
SQL Server Quick Start and T-SQL Cheat Sheet Getting productive on Microsoft SQL Server fast when you already know PostgreSQL or MySQL — connecting with sqlcmd and the modern clients, running the engine in a container, the T-SQL dialect essentials (TOP, OFFSET/FETCH, MERGE, CTEs, window functions), indexes and execution plans, stored procedures, backup and restore, and the dialect gotchas that trip up newcomers.
-
Trino: One Query Engine Over Everything Trino is a distributed MPP SQL engine that queries data where it lives — across object storage, relational databases, and streaming systems — without loading it into a central warehouse first. This guide covers the architecture, connectors, optimizer, failure model, and honest operational realities.
-
ClickHouse for Analytics Workloads ClickHouse columnar storage, the MergeTree engine family, primary key vs sorting key, materialized views for pre-aggregation, query profiling with EXPLAIN, replication with ClickHouse Keeper, distributed tables for sharding, and when to choose ClickHouse over PostgreSQL.
-
PgBouncer and PostgreSQL Connection Pooling Why PostgreSQL's process-per-connection model requires a connection pooler, PgBouncer session vs transaction vs statement pooling modes and their tradeoffs, pgbouncer.ini configuration, monitoring with SHOW commands, and a comparison of PgBouncer, Pgpool-II, and Supavisor.
-
PostgreSQL Internals and Tuning How PostgreSQL works under the hood: MVCC for non-blocking reads, heap and TOAST storage, WAL for durability and replication, VACUUM and autovacuum mechanics, EXPLAIN ANALYZE output explained, index types, pg_stat_statements for query analysis, and key postgresql.conf tuning parameters.
-
PostgreSQL Replication and High Availability PostgreSQL streaming replication setup, synchronous vs asynchronous tradeoffs, logical replication for selective sync and zero-downtime upgrades, pg_basebackup for standby creation, Patroni with etcd for automatic failover, pg_rewind for rejoining a former primary, and monitoring replication lag.
-
Redis Architecture and Persistence Redis data structures and their use cases, RDB vs AOF vs hybrid persistence, Redis Sentinel for high availability, Redis Cluster for horizontal scaling with hash slots, eviction policies, diagnostic commands, and an honest look at when Redis is the right tool.
-
Kafka Connect Deep Dive A comprehensive guide to Kafka Connect — connector architecture, Debezium CDC, Single Message Transforms, exactly-once delivery, schema evolution with Schema Registry, and running at scale on Kubernetes with Strimzi.
-
Delta Lake vs Iceberg vs Hudi: The Table Format Shootout A clear-eyed comparison of the three open lakehouse table formats — Delta Lake, Apache Iceberg, and Hudi — covering ACID transactions, schema evolution, time travel, and which engine ecosystems back each one.
-
Apache Airflow Deep Dive: DAGs, Executors, and Production Realities A production-focused guide to Apache Airflow — how DAGs, schedulers, and executors really work, where Airflow shines and where it hurts, and what you need to know to run it reliably rather than inherit it and suffer.
-
Apache Spark Fundamentals: RDDs, DataFrames, Catalyst, and When Spark Still Wins How Apache Spark actually works under the hood — RDDs, DataFrames, the Catalyst optimizer, and the execution model — and an honest look at when Spark still wins versus DuckDB, Trino, Polars, and Flink.
-
Standalone Ceph Without Proxmox: cephadm, Pool Design, and Day-2 Operations Running Ceph on plain Linux without Proxmox hiding the complexity — bootstrapping with cephadm, designing pools and CRUSH rules for your hardware, exposing RBD, CephFS, and RGW, and the day-2 operations that keep a cluster healthy.
-
Btrfs in Production: Snapshots, Send/Receive, Quotas, and the Pitfalls An honest assessment of running Btrfs in production — what it gets right with snapshots, send/receive, and transparent compression, where it's still dangerous with RAID5/6, and how to use its quotas and tooling without getting burned.
-
fio Benchmarking Cookbook: Stop Using dd, Start Measuring What Matters Why `dd` tells you almost nothing about storage, and how to measure what matters with fio — building realistic jobs for IOPS, throughput, and latency across queue depths so your numbers reflect real workloads rather than cache.
-
LUKS and Full-Disk Encryption: Root Partitions, TPM Unlock, and Key Management Full-disk encryption on Linux with LUKS beyond the installer defaults — how dm-crypt and LUKS headers work, keyslot and key rotation, TPM-backed and automated unlock, and a recovery plan for when you need one years later.
-
MinIO: Self-Hosted S3 — Deployment, Erasure Coding, and Performance Tuning Running MinIO as self-hosted, S3-compatible object storage — deployment topologies, how erasure coding protects data, and performance tuning for line-rate throughput on commodity hardware, with a clear-eyed note on recent licensing changes.
-
XFS Tuning and Internals: Allocation Groups, Log Layout, and Real Workload Tuning What's actually happening underneath the Linux filesystem you've used by default for years — XFS allocation groups, the journal layout, and the tuning that matters for real workloads like large, full, write-heavy volumes.
-
Proxmox + Ceph: Hyperconverged Storage Deep Dive A complete guide to building hyperconverged storage with Proxmox VE and Ceph: OSD placement, CRUSH maps, erasure coding, pool configuration, SSD vs HDD tuning, and building a production-grade cluster.
-
Proxmox Backup Server In Depth A comprehensive guide to Proxmox Backup Server: deduplication internals, encryption, tape support, replication between PBS instances, retention policies, restoring at scale, and operating PBS reliably in production.
-
R for Data Analysis: A Practical Guide for Engineers A technically honest guide to R for experienced engineers and data practitioners — covering Tidyverse, ggplot2, R Markdown, Shiny, statistical modeling, and a frank R vs Python comparison.
-
Apache Iceberg: Table Format for the Data Lakehouse How Apache Iceberg brings ACID transactions, schema evolution, hidden partitioning, and time travel to object storage — with Spark, Trino, DuckDB, and Flink.
-
Building Internal Data Platforms: The Modern Data Stack in Practice A practical guide to building an internal data platform — combining dbt, Airflow, data warehouses, data contracts, and data quality checks into a coherent system your engineers and analysts actually want to use.
-
Change Data Capture with Debezium: Streaming Database Changes in Real Time A comprehensive guide to Change Data Capture with Debezium—covering how CDC works at the database level, setting up connectors for PostgreSQL and MySQL, routing events through Kafka, handling schema evolution, transforming records with SMTs, and building production-grade CDC pipelines.
-
ClickHouse for Observability: Logs, Metrics, and Traces at Scale How ClickHouse's columnar storage architecture makes it the ideal backend for logs, metrics, and traces at scale — replacing Elasticsearch with a fraction of the resources.
-
dbt Core in Practice: Data Modeling That Doesn't Rot A complete hands-on guide to dbt Core — project structure, sources and staging layers, testing data quality, documentation, incremental models, and running dbt in production with Airflow.
-
DuckDB for Analytics Engineers: In-Process OLAP That Replaces Your Spark Cluster A comprehensive guide to DuckDB—covering its columnar vectorized execution engine, querying Parquet and S3 directly, replacing heavy Spark jobs for medium data workloads, Python and R integration, performance tuning, and when to use DuckDB vs alternatives.
-
PostgreSQL Performance Tuning: From Slow Queries to a Database That Purrs A practical deep dive into PostgreSQL performance: reading pg_stat_statements, analyzing slow queries with EXPLAIN ANALYZE, choosing the right index type, tuning autovacuum, and scaling connections with PgBouncer.
-
Real-Time Streaming with Apache Flink: Stateful Stream Processing at Scale A deep dive into Apache Flink — stateful stream processing, windowing, exactly-once semantics, checkpointing, and deploying production Flink jobs on Kubernetes.
-
Redis Beyond Caching: Streams, Pub/Sub, Search, and When Redis Is Your Primary Database A deep dive into Redis beyond the cache: pub/sub messaging, Streams for event logs, RedisJSON for document storage, RediSearch for full-text search, persistence modes, and HA with Cluster vs Sentinel.
-
Apache Kafka Deep Dive A comprehensive guide to Apache Kafka — how it works internally, producers and consumers, partitions and consumer groups, exactly-once semantics, schema management, and running Kafka reliably in Kubernetes with Strimzi.
-
Data Pipeline Patterns: ETL vs ELT, Streaming, Batch Processing, and Orchestration A practical guide to data pipeline architecture — ETL vs ELT trade-offs, streaming with Kafka and Flink, batch transformation with dbt, and orchestration with Airflow and Dagster.
-
Database Migrations Without Downtime: Expand/Contract, Shadow Tables, and Safe Deploys A practical guide to running database schema changes against a live production database without downtime — the expand/contract pattern, rename and backfill strategies, shadow tables for rewrites, lock-aware migrations, and tooling that makes it safe.
-
Object Storage Internals: How S3-Compatible Storage Works and Self-Hosting with MinIO A deep dive into how S3-compatible object storage works under the hood — consistency models, multipart uploads, lifecycle policies, erasure coding, and running production-grade storage with MinIO.
-
PostgreSQL for Developers: Indexes, EXPLAIN ANALYZE, JSONB, and Tuning for Real Workloads A practical deep-dive into PostgreSQL for developers — understanding indexes and when to use them, reading EXPLAIN ANALYZE output, using JSONB for flexible schemas, and tuning the key configuration knobs that matter for real workloads.
-
SQLite in Production: When It's the Right Choice, WAL Mode, Backups, and Litestream Replication SQLite is more capable in production than most developers realize. This guide covers when to choose it over Postgres, WAL mode for concurrent reads and writes, proper backup strategies, and continuous replication with Litestream.
-
Time-Series Data with InfluxDB and TimescaleDB A practical guide to modelling, storing, and querying time-series data with InfluxDB and TimescaleDB — including retention policies, downsampling, and real-world sensor data patterns.