LLM Core Interview Prep
Test & Track Your Readiness

Strip the marketing. A large language model is a next-token predictor trained on a giant corpus with a transformer architecture. This module builds the right mental model for everything that follows.

The three training stages — pretraining on web-scale data, supervised fine-tuning on instructions, RLHF/DPO for alignment. What each stage produces, why it matters, what you can and can't change downstream.

Tokenisation (BPE), why 'GPT-4' counts differently than 'gpt4', what context windows really cost, when long context becomes a lie, attention compute scaling.

What embeddings actually represent, the geometry of meaning, cosine vs dot-product, dimensions and pricing, when embeddings break down, the bridge to RAG.

The patterns that work in production: system vs user roles, few-shot exemplars, chain-of-thought (and when not), self-consistency, the prompts you should never write, prompt versioning.

JSON mode vs constrained decoding vs function calling — the modern reliability story for LLM outputs. Schema design, retries, validation, parsing failures.

Why every serious LLM app streams, Server-Sent Events vs WebSockets, perceived-latency tricks (first-token-time, partial UIs), abort handling, streaming with structured outputs.

OpenAI vs Anthropic vs Google vs open-source — what each is genuinely best at in 2026, when each loses, pricing trends, the second-source argument, lock-in.

Pricing math beyond per-token rates: input vs output cost asymmetry, prompt caching, batch API, model-tier selection, real production cost traps with numbers.

Llama, Mistral, DeepSeek, Qwen — what's actually production-ready in 2026, when self-hosting beats API cost, vLLM and TGI, Ollama for dev, the operational reality.

What goes into the context window and in what order — the most underrated skill in 2026. Context rot, lost-in-the-middle, the difference between RAG and 'just shove everything in', dynamic context construction.

How to evaluate an LLM app without lying to yourself. Golden datasets, LLM-as-judge (and when it lies too), regression detection, the things benchmarks don't measure.

Three layers of cache that change LLM economics: prompt caching (provider-native), semantic caching (embeddings + similarity), and KV cache awareness for self-hosted serving.

The bugs every team hits — hallucinations treated as bugs not features, retry storms, structured-output silent failures, LLMs as if-statements, prompt regression on model upgrade.

From prototype to production. Observability, rate limiting, abuse handling, model failover, prompt versioning, evaluation gates in CI/CD, the production checklist.

Tool calling as an agentic primitive — the loop that drives modern LLM apps. Tool schemas, parallel calls, result formatting, dedup, streaming, sensitive-tool guardrails, and prompt-injection defense on tool results.

The o-series, Claude extended thinking, DeepSeek R1, Gemini thinking. When to use, prompting differences, budgeting thinking tokens, routing patterns, and how reasoning combines with tool use.

Natively multimodal frontier models: vision for docs/charts/screenshots, Whisper and GPT-4o Realtime for audio, Gemini for video. Preprocessing, cost per modality, structured extraction from images, adversarial injection via images.

When fine-tuning beats prompting, dataset construction, LoRA/QLoRA on Llama/Mistral, managed vs DIY, evaluation discipline, distillation from frontier models, deployment via adapter hot-swap.

OWASP LLM01 in depth: direct vs indirect injection, guard models, trust tiering for RAG, jailbreak categories, data exfiltration, multimodal injection, red-team suites, and the realistic defense-in-depth baseline.

OpenTelemetry semantic conventions for LLMs, trace-span model for multi-step agents, cost attribution, sampled quality evaluation, alerting on user impact, and the tooling landscape (LangSmith, Phoenix, Braintrust, Helicone).

Sub-8B models in 2026: Phi-4, Gemma 3, Llama 3.2 1B/3B, Qwen 2.5, distilled reasoning. Quantization (GGUF, AWQ, MLX), runtimes (llama.cpp, Ollama, WebLLM, MediaPipe, ExecuTorch), mobile and browser deployment, hybrid small-local + big-cloud routing.