// Track

AI Infrastructure in Production

From 'It Runs on My Machine' to an Observable, Autoscaled LLM Service

A working prototype is 20% of production. This Elite masterclass teaches the deploy-and-operate layer most operators skip: containerize an AI service, orchestrate it on Kubernetes with GPU scheduling, serve an LLM with vLLM, provision it with Terraform, and prove it healthy with SLOs and error budgets — ending in a graded end-to-end capstone. Inference-first, single-stack, grounded in Knox's real systems (semantic memory layer, Mission Control, and a persistent server). Curriculum scaffolding inspired by the open-source AI Infrastructure Engineer Learning track (VeriSwarm.ai, MIT); all lessons, diagrams, and examples are original.

Recommended: Complete Building Production MCP Servers first

12 lessons~123 min total

Lessons are shown in recommended order. Complete them in sequence for the best experience — or jump to any lesson.

Lesson 481·9 min read

Why "It Runs on My Machine" Isn't Production

A working prototype is 20% of production. This lesson defines the operator's layer — the deploy-and-operate stack that keeps an AI service alive after you close the laptop.

Lesson 482·11 min read

Containerizing an AI Service

Freeze your AI service into a small, non-root, reproducible image. Multi-stage builds, layer-cache ordering, and the Dockerfile you write yourself.

Lesson 483·11 min read

Kubernetes for Operators

Just enough Kubernetes to be a confident operator — the control plane, the five objects you actually touch, and the reconcile loop that runs underneath all of it. No cargo cult.

Lesson 484·12 min read

GPU Scheduling & Autoscaling

How a Pod gets a whole GPU, and how the Horizontal Pod Autoscaler reconciles replicas against the metric that actually predicts an outage. You write the Deployment and the HPA.

Lesson 485·9 min read

Serving an LLM with vLLM

PagedAttention, continuous batching, and how to pick the right serving profile so one GPU does the work of three.

Lesson 486·10 min read

RAG in Production

The retrieve → rerank → cache → generate path, built the way Semantic Memory Layer actually runs it: local MiniLM embeddings, ChromaDB, and a semantic cache that pays for itself.

Lesson 487·9 min read

Inference Economics

Four levers that decide your inference bill — quantization, prefix caching, spot, and scale-to-zero — ranked by dollar impact against quality risk.

Lesson 488·10 min read

Infrastructure as Code

The write → plan → apply → state loop, remote state with locking, and a Terraform module that provisions the GPU node pool your inference service runs on.

Lesson 489·9 min read

Observability — The Three Pillars

Metrics tell you something broke, logs tell you what, traces tell you where. Wire all three into your LLM service or debug blind in one dimension.

Lesson 490·11 min read

SLOs, Error Budgets & On-Call

An SLO without an error budget is a wish. Turn 'how reliable?' into a number you can spend — and measure it against artifact health, not a heartbeat.

Lesson 491·10 min read

Shipping Safely — Canary, Blue-Green & Drift

Choose a deployment strategy by what rollback costs you — and remember that deploy is where the clock starts, not the finish line. Models drift.

Lesson 492·12 min read

Capstone — Deploy an Observable LLM Service

The graded end-to-end build: containerized, orchestrated, served, observed, SLO-defined. Every box must be demonstrable on a running system — not described, shown.