#Infrastructure
380 posts
PostgreSQL Basics #5 Reading EXPLAIN: Diagnosing Queries with Execution Plans
How to confirm why a query is slow with the execution plan instead of guesswork. The difference between EXPLAIN and EXPLAIN ANALYZE (the latter actually executes), reading the plan tree from the innermost node outward, what Seq Scan, Index Scan, Index Only Scan, and Bitmap Scan mean, comparing cost and actual time and estimated vs actual rows, the remedy when estimates are badly off (ANALYZE), and the habit of checking read volume with BUFFERS.
PostgreSQL Basics #4 Index Fundamentals: When Indexes Get Used and When They Don't
Indexes are a reliable way to make reads fast, and this chapter grounds them in PostgreSQL specifics. How a B-tree index changes lookups, the classic reasons an index you created is not being used (leading-column mismatch, functions applied to the column, type mismatch, low selectivity), the cost in write performance and storage, and the working order of "build from the WHERE, JOIN, and ORDER BY of actually slow queries."
PostgreSQL Basics #3 Joins and Aggregation: Working Instincts for Read Queries
Joins and aggregation make up most of real-world read queries, and this chapter builds the instincts. Choosing between INNER and LEFT JOIN and the classic mistake of filtering LEFT JOIN results in WHERE (turning them back into INNER), the division of labor between GROUP BY and HAVING, the double-counting trap when joins meet aggregation, the fork between subqueries and joins, and the PostgreSQL-native way to get the latest row per group (DISTINCT ON).
PostgreSQL Basics #2 Data Types and Table Design: What to Store Things As
Half of PostgreSQL design is choosing data types. Why text alone is enough for strings, why numeric is mandatory for money, timestamptz as the standard for points in time and the timestamp trap, primary key strategy (bigint IDENTITY vs UUID, and uuidv7), enforcing data integrity at the database layer with NOT NULL, CHECK, and foreign keys, and where enums and arrays belong.
PostgreSQL Basics #1 What PostgreSQL Is: Why It Became the Default, Installation and First psql Session
Starting from why PostgreSQL became the default database for new projects: standards compliance, a rich set of data types, the extension ecosystem (pgvector, PostGIS), and a permissive license. Then the fastest local setup with Docker, connecting with psql and the essential meta-commands (\l, \dt, \d), a first cycle of creating a table, inserting, and querying, and a map of the whole course.
LLM Hallucinations: Causes and Practical Countermeasures
A summary of hallucination, where LLMs confidently generate plausible falsehoods: why it follows inevitably from next-token probability prediction, the common types from factual errors to fabricated citations and code API hallucinations, the measures that actually reduce it in practice — RAG, enforced citations, tool use, structured output validation, evaluation pipelines — and the operational view of designing human review points on the premise that it can never be fully eliminated.
Embeddings and Vector Search: How Semantic Search Actually Works
A single-post summary of embeddings and vector search, the foundation of RAG and semantic search: the concept of turning text into numeric vectors, measuring semantic closeness with cosine similarity, the trade-off between exhaustive kNN and approximate ANN indexes, choosing storage between pgvector, dedicated vector databases, and search-engine extensions, where embeddings fall short on exact keyword matching and why hybrid search is the practical standard, plus operational costs like full re-indexing on model changes.
Tokens and Context Windows: The Units That Decide LLM Cost and Limits
A single-post summary of tokens and context windows, the units behind every LLM price sheet and spec table: how text gets split into tokens, why non-English languages cost more tokens, the asymmetric input/output pricing and why long conversations get expensive fast, what the context window actually limits, the performance traps of very long context, and practical mitigations from prompt caching to history management.
Cutting NAT Gateway Costs: The Data Processing Fee Is the Real Bill
A breakdown of the NAT Gateway bill and the order to cut it: the three overlapping charge layers (hourly, data processing, internet transfer), why downloads get charged too, the cost math of each bypass route from free gateway endpoints through interface endpoints, IPv6, and NAT instances, how to find the traffic culprits, and the cost structure of multi-AZ placement.
How a CDN Makes Things Fast — From Cache Hits to Dynamic Content
CDN mechanics from the practitioner's side: the edge structure that shrinks distance (RTT), the Cache-Control headers and cache keys that decide hit rate, invalidation and deploy strategy, how CDNs help even uncacheable dynamic traffic (TLS termination, connection reuse), and the common mistakes that eat hit rate.
DynamoDB vs RDS: Choosing an AWS Database
A working standard for choosing between DynamoDB and RDS: the data-model difference between key-value and relational, how per-request versus per-instance-hour billing splits the bill, DynamoDB's constraint of designing access patterns up front, the trap of GSIs multiplying write costs, a selection order driven by traffic patterns, and the setup that runs both side by side.
Why Redis Is Fast — Memory, a Single Thread, and Data Structures
The structural reasons Redis handles hundreds of thousands of requests per second: memory access with no disk in the path, a lock-free single-threaded event loop, and purpose-built data structures — plus the single-thread trap (one slow command stalls everything) and the cases where Redis gets slow.