Infrastructure
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.
MCP (Model Context Protocol) Explained: The Standard for AI Tool Use
A single-post summary of MCP, the protocol that keeps appearing in agent articles: how a standard interface turns the N-by-M tool-integration problem into N-plus-M, its relationship to function calling, hosts, clients, servers and the tools/resources/prompts primitives, adoption status and foundation governance as of 2026, security cautions from third-party server trust to prompt injection, and when adopting it is worth it — and when it is not.
What a Database Index Actually Does — B-trees, Lookup Cost, and the Price of Writes
How indexes make lookups fast, from the B-tree up: the cost gap versus full scans, composite indexes and column order, why indexes are not free (write cost, storage), and the working rules for what to index and what to leave alone.
RAG vs Fine-Tuning vs Long Context: Getting Knowledge Into an LLM
A working standard for the three ways to get your data into an LLM: the structural difference between retrieving and injecting (RAG), modifying weights (fine-tuning), and stuffing everything in with caching (long context), the boundary that fine-tuning teaches behavior rather than knowledge, a selection order driven by knowledge size and update frequency, and the practical setup that combines all three.
When a REST API Is Slow — the Order for Finding the Bottleneck
Finding API bottlenecks by procedure instead of instinct: instrumenting to split the request into segments, the four usual suspects (database, serialization, external calls, N+1), the priority order of fixes like caching and pagination, and why p99 matters more than p50.
RI vs Savings Plans: Choosing an AWS Commitment Discount
A working standard for choosing between Reserved Instances and Savings Plans: the structural difference between matching instance attributes and committing to an hourly spend, the flexibility split behind the identical 72% maximum discount, the services Savings Plans cannot cover (RDS and friends), capacity reservation as a separate problem, and how to size a commitment against the stable floor of your bill.
What Load Average Actually Is — and How It Differs from CPU Usage
Reading the most misread metric in Linux correctly: the definition (running + runnable + disk-wait D-state tasks), judging against core count, the four classic ways it diverges from CPU usage, and reading the 1/5/15-minute triple as a trend.