June 2026¶

You can't use a USB drive as VRAM — the enterprise guide to GPU memory capacity planning in 2026

Storage isn't VRAM. eGPUs aren't a data center strategy. Shared memory isn't a capacity plan. Every quarter, an AI infrastructure team somewhere asks the same question: "we're running out of GPU memory, can we just use the SSDs?" No. Here's what actually works at scale, what doesn't, and the procurement and capacity planning playbook for GPU memory in 2026.

This post is written for AI platform engineers, infrastructure architects, and FinOps leads running shared GPU clusters. It's not about a single workstation — it's about a fleet. The unit of analysis is the rack, the budget, and the quarter.

Once the fleet exists, two companion posts cover what runs on it: engine selection and quantization (which engine, which precision, when to call an API instead) and GPU Autoscaling is Broken (scaling LLM inference under real load). This one is the layer above both: how much GPU memory to buy in the first place.

The backend-for-frontend pattern for AI apps: thin client, fat API, one job

Most AI apps in 2026 still ship as "browser → OpenAI" with an API key in the frontend bundle. This is broken in every dimension that matters: security, cost, observability, provider lock-in, and rate limiting. The fix is a Backend-for-Frontend (BFF) — a thin server between the browser and the LLM provider that owns auth, cost, streaming, and provider abstraction. The browser does UI. The BFF does everything else.

This is the pattern every serious AI product has converged on by 2026. Here's what it looks like, why each piece exists, and how to build it without over-engineering.

Streaming responses in 2026: SSE vs WebSockets vs gRPC for AI apps

Every AI app needs to stream. Most teams pick the wrong transport and spend a week debugging why the first token takes 8 seconds. The LLM is fast — the network in front of it isn't. This post compares the three transports that actually work in production (SSE, WebSockets, gRPC streaming), shows the buffering traps that kill streaming, and gives you the decision framework to pick the right one in 30 seconds.

If you've ever shipped a "ChatGPT-style" streaming endpoint and watched it work in dev, then break in staging behind nginx, this is the post for you.

GPU Autoscaling is Broken: What I Learned Scaling LLM Inference to 10K QPS

Standard Kubernetes autoscaling assumes more load = more pods = more capacity. With stateless REST APIs, that works. With LLM inference, it falls apart — and it took us three months of production pain at 10K QPS to figure out why.

This post covers the four patterns that actually worked, the exact configs we run, and the numbers before and after: p99 latency from 12s down to 1.8s, OOM kills from 3% to under 0.1%, GPU utilization from 40% to 75%.

Two companions go alongside this one: engine selection and quantization (which engine and precision to run before you scale anything) and the GPU memory capacity-planning guide (how much GPU to buy in the first place).

The Claude Code Project Template That Closes the Loop: PRD → Plan → Build → Validate → Track

Most people use Claude Code like a chat window: type a request, accept the diff, repeat until it works or breaks. That's fine for a one-off script. For a real project it falls apart fast — the agent forgets decisions, rebuilds things it already built, and you lose track of what's actually done.

The fix isn't a smarter model. It's a project structure that gives the agent memory, process, and guardrails. I found a template that nails this: code-template — a Claude Code starter that defines the full coding loop with 5 files and 3 slash commands. This post walks through how it works and why each piece earns its place.

Hybrid RAG in Production: A Full n8n + Airflow Implementation

You've got the concepts — chunking, hybrid search, reranking, GraphRAG. This is the wiring diagram. A complete hybrid RAG system you can import and run: ingestion on Apache Airflow, the query pipeline on n8n, retrieval fused across dense, BM25, GraphRAG, and live web.

This is the companion build to Agentic Retrieval: The Complete Guide. Every technique there, ported into nodes and DAG tasks you can click, run, and adapt — with a local-first swap for every cloud component.

Building a Production RAG App: The Decisions, the Traps, and the Fixes

I built a full-stack RAG application — streaming chat, document ingestion, hybrid search, sub-agents, admin-managed model config — and most of the hard parts had nothing to do with calling an LLM. The LLM call is 20 lines. The other 95% is retrieval quality, ingestion correctness, and not blocking your event loop.

This walks through the real decisions and the traps I hit: where naive RAG breaks, and the exact fix that shipped. Every number here is from the running code, not a whitepaper.

All the code is open source: github.com/pkhamdee/rag. Every snippet below links to the file it came from, so you can read the full implementation in context.

Credit: the template's structure and workflow originate from the Claude Code Agentic RAG Masterclass

Agentic Retrieval: The Complete Guide from Document Ingestion to Compiled Knowledge

Naive RAG fails roughly 40% of the time at retrieval. Not because the LLM is bad — because what you hand it is bad. Wrong chunks, missing context, no awareness of what it doesn't know. Agentic retrieval fixes the retrieval layer, not the generation layer.

This guide covers the entire pipeline: from ingesting a raw PDF to deploying an agent that queries vector stores, SQL databases, knowledge graphs, and pre-computed summaries — and knows which one to use for each question.

The Math Behind an Entire LLM: From Tokens to Fine-Tuning

Most LLM explainers either skip the math entirely or dump you into a research paper. This one is neither. We'll walk every equation with real numbers, using the same three-token sentence — "The cat sat" — all the way from raw text to gradient updates.

By the end, you'll be able to trace any weight in any layer and know exactly what changed it, why, and by how much.

Build a Second Brain with Claude Code and Obsidian

Most note-taking apps are graveyards. You clip an article, it sits in a folder, you never read it again. The knowledge doesn't connect to anything. It doesn't compound. After three years you have 4,000 notes and can't find anything.

This guide builds something different: a self-maintaining knowledge base where Claude Code acts as your librarian. You dump raw material in. Claude reads it, writes structured wiki articles, cross-links related concepts, and files everything. You ask questions. The answers become new notes. The library grows smarter every time you use it.

The architecture is based on Andrej Karpathy's LLM Wiki pattern: a persistent, compounding knowledge base where an LLM does the bookkeeping you'd never do yourself.