Match each schema validation pattern to the production scenario where it fits best.

Structured output from an LLM is rarely a one size fits all problem. Five common patterns each fit a different shape of production constraint. Provider-native structured output (OpenAI's response_format, Anthropic's tool-use, OpenAI Structured Outputs with strict JSON schema) is the simplest integration. You hand the provider a schema and the provider enforces it. The cost is provider lock-in and accepting whatever level of strictness they give you. Pydantic plus Instructor in Python, or Zod plus runtime validation in TypeScript, both work by validating the model's output after the fact and retrying on failure. They fit naturally when the rest of your codebase already speaks Pydantic or Zod. A hand-rolled JSON Schema plus a repair loop is the most portable choice. You define the schema, validate, and prompt the model to fix any errors. It works with any LLM but you write the loop yourself. Grammar-constrained decoding (Outlines, llama.cpp grammars, Guidance) is the strictest. The decoder physically cannot emit invalid tokens. You pay 10 to 20 percent latency and you usually need a local model, but the output is guaranteed valid. Match the pattern to your ecosystem, your tolerance for retries, and how much you can spend on latency.

Schema validation for LLM outputs splits into five common patterns. The right choice depends on two axes: language ecosystem and strictness budget. `Pydantic + Instructor` fits Python backends that already speak Pydantic. Instructor wraps the LLM call, parses the response into the Pydantic model, and retries on validation failure. You get type-safe outputs at the cost of one possible retry per call. `Zod + TypeScript` is the symmetric fit for Node and Next.js codebases. The rest of the type system is Zod-driven, and runtime guards line up with compile-time types. A hand-rolled `JSON Schema + repair loop` is the provider-agnostic choice. You write the validate and retry loop yourself; it works with any LLM that accepts a JSON hint. The cost is the loop code and the occasional retry. The benefit is portability across providers. Provider-native structured-output mode (OpenAI `response_format` with strict JSON schema, Anthropic tool-use, Gemini structured output) is the simplest integration. You hand the provider a schema, the provider's decoder enforces it, and you avoid the loop. The cost is provider lock-in and whatever strictness ceiling they offer. Grammar-constrained decoding (Outlines, llama.cpp grammars, Guidance) is the strictness ceiling. The decoder masks logits to physically prevent invalid tokens. Output is guaranteed valid against the grammar. The cost is 10 to 20 percent latency, usually a local model, and a grammar definition. Pick it when downstream consumers (embedded systems, deterministic pipelines) cannot tolerate any malformed output.