# Learn Backend > You already ship backend systems. Learn to ship LLM systems to production: RAG, agents, evals, cost and latency. A free, text-first track for engineers. ## AI Engineering for Backend Developers A free, text-first track that takes an experienced backend engineer from zero LLM experience to shipping production AI systems: LLM APIs, structured output, RAG, agents, evals, observability, and cost/latency engineering. Every lesson assumes you already know APIs, databases, and queues, because that knowledge is your advantage. - [What LLMs Actually Do](https://learnbackend.com/ai-engineering/llm-foundations/what-llms-actually-do/): A backend engineer's mental model for LLMs: next-token prediction, weights vs context, stateless chat APIs, and why hallucination is a property to engineer around. - [Tokens, Context Windows, and Your New Resource Limits](https://learnbackend.com/ai-engineering/llm-foundations/tokens-context-windows-and-limits/): Tokens are the byte of LLM systems: the unit of billing, latency, and memory. Learn to budget a context window and calculate real monthly costs before you ship. - [Your First LLM API Call](https://learnbackend.com/ai-engineering/llm-foundations/your-first-llm-api-call/): Demystify LLM APIs with raw curl calls, message roles, the parameters that matter, streaming, and key hygiene, for backend engineers. - [How to Choose an LLM in 2026: A Backend Engineer's Decision Framework](https://learnbackend.com/ai-engineering/llm-foundations/choosing-a-model-like-a-database/): A backend engineer's map of the mid-2026 LLM landscape: model tiers, real costs per million tokens, and a decision framework that actually works. - [LLM Latency, Cost, and Non-Determinism in Production: Where Backend Instincts Break](https://learnbackend.com/ai-engineering/llm-foundations/non-determinism-latency-and-cost/): Three properties of LLM calls that violate backend intuition (non-deterministic output, alien latency profiles, and token-based cost) and what to do about each. - [The Production LLM Stack: Every Component, Mapped to Backend Infrastructure](https://learnbackend.com/ai-engineering/llm-foundations/the-production-ai-stack/): A component-by-component tour of a production LLM system, each piece mapped to backend infrastructure you already run, and the roadmap for this track. - [Pin Your Model Like You Pin Your Packages](https://learnbackend.com/ai-engineering/working-with-llm-apis/model-versioning-and-deprecations/): Model IDs are versions, aliases move under you, and deprecations have deadlines. How to pin, monitor, and upgrade your LLM dependency like any other. - [The API Is Stateless. Your Chat Isn't.](https://learnbackend.com/ai-engineering/working-with-llm-apis/conversation-state-and-history/): The LLM API keeps no session state, so your chat feature needs a transcript store, a token budget, and a truncation strategy. Build all three. - [What's Actually in the Stream](https://learnbackend.com/ai-engineering/working-with-llm-apis/anatomy-of-an-llm-stream/): What an LLM stream actually sends: OpenAI chunks vs Anthropic events, delta aggregation, mid-stream errors, and canceling generations nobody is reading. - [When the Model Has a Bad Day](https://learnbackend.com/ai-engineering/working-with-llm-apis/failure-modes-and-degradation/): LLM calls fail three ways: real errors, hangs, and 200s that lie. Map each failure to what your API serves instead, from a cached copy to a hidden feature. - [Rate Limits Are a Capacity Contract](https://learnbackend.com/ai-engineering/working-with-llm-apis/rate-limits-and-capacity/): RPM and TPM are capacity contracts, not suggestions. Read the rate-limit headers, throttle client-side, and plan token headroom before the 429s arrive. - [Abstract the Provider, Not the Prompt](https://learnbackend.com/ai-engineering/working-with-llm-apis/provider-abstraction/): Design the one seam every LLM call goes through: a normalized client interface over OpenAI and Anthropic dialects, and when to buy a gateway instead. ## Guides Decision guides and comparisons for shipping LLM systems from an existing backend stack. - [LLM API Retries, Timeouts, and Fallbacks: A Production Playbook](https://learnbackend.com/guides/llm-api-retries-timeouts-fallbacks/): An error-by-error playbook for LLM calls: which failures to retry (and which never), stage-aware timeouts, model fallback chains, and why naive retries are a money bug. - [pgvector vs Pinecone vs Qdrant: Choosing a Vector Store for Your Existing Backend (2026)](https://learnbackend.com/guides/pgvector-vs-pinecone-vs-qdrant/): A backend engineer's decision framework for vector storage: when pgvector in your existing Postgres wins, when a dedicated engine earns its keep, and the sync-pipeline tax nobody prices in. - [How to Stream LLM Responses: SSE vs WebSockets (and the Fetch-Stream Option)](https://learnbackend.com/guides/streaming-llm-responses-sse-vs-websockets/): Which transport to stream LLM tokens through your backend (SSE, raw fetch streaming, or WebSockets), with a relay implementation, proxy gotchas, and a decision table. - [How to Add an LLM to Your Existing Backend Without Rewriting It: 6 Integration Patterns](https://learnbackend.com/guides/add-llm-to-existing-backend/): Six production patterns for adding LLM features to an existing backend, with code: inline endpoint, queue worker, internal gateway, pgvector retrieval, event enrichment, and flagged rollout. ## Blog - [Relaunching learnbackend.com: AI Engineering for Backend Developers](https://learnbackend.com/blog/relaunching-learnbackend/): Why this site now teaches backend engineers to ship LLM systems to production, and what the free track covers, module by module. ## Feeds - [Full content (plain markdown)](https://learnbackend.com/llms-full.txt) - [RSS](https://learnbackend.com/feed.xml) - [Sitemap](https://learnbackend.com/sitemap.xml)