What you'll learn

• Classify any LLM use case as knowledge-bound, behaviour-bound, or both, using a documented seven-question decision tree
• Decide when prompt engineering alone is genuinely sufficient, and when it is a false economy
• Specify a production RAG pipeline: chunking, embeddings, hybrid retrieval, reranking, grounding, and citation policy
• Assess a dataset and state whether supervised fine-tuning is viable, premature, or simply the wrong tool
• Select and defend a reference architecture that combines techniques, including routing, fallback, and escalation
• Build a cost-per-1,000-requests model and a latency budget for competing designs, and find the crossover point
• Produce a threat model and a production-readiness sign-off pack for an LLM application
• Write an Architecture Decision Record that survives review by an architect, a CISO, and a CFO

Requirements

• Working familiarity with what an LLM is and how an API call works
• Comfort reading an architecture diagram
• No machine learning, maths, or fine-tuning experience required
• Optional, for the Colab lab only: basic Python literacy, as the notebook runs end to end without editing

Description

• This course contains the use of artificial intelligence.

• Most enterprise LLM projects stall on the same question:do we prompt, retrieve, or fine-tune? Pick wrong and you spend six months and a large budget solving a problem the cheapest lever would have solved in three weeks.

• This is not a twenty-hour AI-engineering bootcamp. It is a decision playbook. The deliverable is judgment — the ability to look at a use case and defend a customization decision in front of an architecture review board, a CISO, and a CFO.

What makes this course different

• Decision-first, not tool-first — every section ends by routing a real use case, not by finishing a tutorial

• Enterprise constraints are first-class — cost, latency, privacy, data residency, model risk, and monitoring get real coverage, not an afterthought

• One model company runs the whole course — you follow a single specialty insurer through three real use cases and watch one architecture evolve, rather than nine disconnected demos

• Every section ships a reusable artefact — a decision matrix, an ADR template, a dataset-readiness checklist, a RAG evaluation workbook, a cost calculator, a threat-model template, and a production-readiness checklist

What you will actually do

• Route use cases through a documented seven-question decision tree
• Write and version a structured prompt with a frozen evaluation set
• Specify a production retrieval pipeline and measure its retrieval half separately from its generation half
• Run a lightweight LoRA fine-tune in Colab and audit a dataset for readiness
• Model cost per thousand requests and find the volume where the ordering flips
• Threat-model an LLM feature and complete a production-readiness review
• Write an Architecture Decision Record recommending one approach, with rejected alternatives and their rationale
• You need to know what an LLM is and how an API call works. You do not need a maths background, an ML background, or any fine-tuning experience.

Who this course is for

• AI solution architects designing LLM systems for enterprise use
• Technical product managers scoping LLM features and defending the budget
• Enterprise developers evaluating prompting, retrieval, and fine-tuning options
• Consultants advising clients on practical AI adoption
• IT and security leaders governing LLM deployments
• Teams that have to decide how to customize an LLM and justify the choice