COURSE
AI Engineering for .NET Developers
Production AI engineering for .NET developers. Build AI features that are measured, observable and safe — in C#.
In production — join the waitlistWhat you'll build: JobScout
One job-search assistant, built up across the course
01STRUCTURED OUTPUT
Job-posting normalizer
Messy job posts in, typed C# records out.
The model returns data that deserializes straight into your own types, so the rest of the app never parses free text.
02EMBEDDINGS + PGVECTOR
Semantic job search
Search postings by meaning, not just keywords.
Embeddings stored next to the rest of your data in PostgreSQL with pgvector, queried from C#.
03RAG
Answers with sources
Questions answered from the postings, with citations.
Every answer points back to the postings it came from, so you can check it instead of trusting it.
04AGENTS + TOOLS
Career Assistant agent
An agent that calls your C# methods as tools.
Built with Microsoft Agent Framework: the agent plans, calls tools you expose, and works through multi-step tasks.
05HUMAN-IN-THE-LOOP
Approval before any write
Nothing changes until a human says yes.
Every write action waits for explicit approval, and side effects are idempotent so a retry never does the same thing twice.
06MCP
MCP server
JobScout search, exposed to other AI clients.
A Model Context Protocol server written in C#, so any MCP-capable client can use JobScout search as a tool.
What you'll learn
Production patterns, in C#
- Write provider-agnostic AI code with IChatClient (Microsoft.Extensions.AI)
- Add middleware for logging, caching and telemetry
- Get typed structured output instead of parsing text
- Build semantic search with embeddings and pgvector
- Answer questions with RAG and citations
- Expose C# methods to the model as tools
- Build agents and workflows with Microsoft Agent Framework
- Add human-in-the-loop approval and idempotent side effects
- Build and publish an MCP server in C#
- Defend against prompt injection
- Trace every model call with OpenTelemetry
- Measure performance with BenchmarkDotNet
- Gate CI on evals, so regressions fail the build
LOCAL-FIRSTEverything runs on free local models with Ollama, so you can follow along without paying for an API.
Who it's for
FOR YOU IF YOU ARE
- C#/.NET backend developers who want to ship AI features to production
- Developers who care about measuring, observing and securing what they ship
NOT FOR YOU IF YOU WANT
- A beginner C# course: you should already be comfortable with C# and .NET
- An ML or model-training course: you use models, you do not train them
The stack
Current .NET, end to end
- .NET 10
- Microsoft.Extensions.AI
- Microsoft Agent Framework
- MCP C# SDK
- Ollama
- PostgreSQL + pgvector
- .NET Aspire
- OpenTelemetry
- BenchmarkDotNet
- Blazor
Curriculum
Build a real AI application in C# from your first local model call to a tested, observable, secure and deployed system, and measure every step.
- In production
- 16 modules
- 135 videos + 5 reading lessons
- ~17 hours of video
- .NET
- Blazor
- NuGet
- Docker
- PostgreSQL
- Redis
- Ollama
- Model Context Protocol
- OpenTelemetry
- Prometheus
- Grafana
- Keycloak
- GitHub Actions
Running project: JobScout, a job search app that reads messy job postings, searches them by meaning in many languages, matches them to a CV, answers questions with sources, and keeps a person in control of every change.
MODULE 01Free preview
Welcome: What You Will Learn and How This Course Works
Find out what you will learn, which problems you will solve with more confidence, what you will build, and how the course works. Then set up and check your machine with short reading lessons.
Learning outcomes
- After this module you know what you will be able to build and measure with AI in .NET by the end of the course.
- After this module you can name the problems this course prepares you for: wrong model answers, slow responses, unsafe inputs, and "it worked yesterday".
- After this module you know the engineering skills around AI you will practise: Aspire, PostgreSQL with pgvector, Redis, OpenTelemetry, testing and CI.
- After this module your machine is ready: .NET 10, Docker, Ollama and the course models are installed, measured and checked with one command.
Lessons
- 01.01What You Will Learn~4 min
- 01.02Problems You Will Solve with Confidence~4 min
- 01.03Not Only AI: The Engineering Around It~4 min
- 01.04The Project: JobScout~5 min
- 01.05How This Course Works~5 min
- 01.06ReadingPrerequisites and Hardware~5 min read
- 01.07ReadingInstall .NET 10, Docker and Your IDE~10 min read
- 01.08ReadingInstall Ollama and Measure Your Machine~10 min read
- 01.09ReadingPick and Pull the Models~10 min read
- 01.10ReadingCheck Your Setup with One Command~5 min read
MODULE 02
Your First AI Call, the Solution Skeleton and LLM Fundamentals
Make your first call to a local model from C#, start the whole JobScout solution with one command, and learn how LLMs behave by measuring them in your own app.
Learning outcomes
- After this module you can call a local model through IChatClient and read what each answer costs in tokens and time.
- After this module you can stream answers to the user while the model is still writing.
- After this module you can start the whole solution with Aspire: API, Worker, Web, PostgreSQL with pgvector, Redis and Ollama, and follow your first trace.
- After this module you can explain tokens, context windows, temperature and hallucination with numbers from your own app.
- After this module you can decide where an LLM belongs and where plain code wins.
Videos
- 02.01Your First IChatClient Call~7 min
- 02.02Streaming Responses~6 min
- 02.03Solution Skeleton with Aspire~10 min
- 02.04Database, Seed Data and Your First Trace~8 min
- 02.05Tokens, Context Windows and Why Limits Matter~7 min
- 02.06Nondeterminism: Temperature and Reproducibility~6 min
- 02.07Hallucination Is a Design Constraint~6 min
- 02.08Local versus Hosted Models~7 min
- 02.09When Not to Use an LLM~6 min
- 02.10Measure Before You Trust: Latency and Tokens~7 min
- 02.11Checkpoint and Solution: JobScout Decision Record~6 min
MODULE 03
Microsoft.Extensions.AI in Depth
Build a provider-independent AI pipeline with middleware, caching, telemetry and testable clients.
After this module you can
- Use IChatClient, ChatMessage and ChatOptions with dependency injection
- Swap AI providers without touching business code
- Write your own middleware for logging and redaction, and add caching and telemetry
- Test AI code with fake and recorded clients, even on a slow machine
Videos
- 03.01IChatClient, ChatMessage and ChatOptions~7 min
- 03.02Dependency Injection and Configuration~7 min
- 03.03Swap Providers without Touching Business Code~7 min
- 03.04The Middleware Pipeline with ChatClientBuilder~8 min
- 03.05Write Your Own Middleware: Logging and Redaction~8 min
- 03.06Response Caching with IDistributedCache~7 min
- 03.07Built-in OpenTelemetry Middleware~7 min
- 03.08Fake and Recorded Clients for Tests and Slow Machines~8 min
- 03.09Checkpoint and Solution: A Configurable AI Pipeline~7 min
MODULE 04
Prompts and Structured Output
Turn messy job postings into typed C# records you can trust.
After this module you can
- Write system prompts as versioned code
- Get typed objects from a model with GetResponseAsync<T>
- Validate, repair or reject model output, and accept "Unknown" as a valid answer
- Process many postings in a batch with channels and backpressure
Videos
- 04.01System Prompts, Roles and Instruction Priority~6 min
- 04.02Prompt Templates as Versioned Code~7 min
- 04.03Structured Output with GetResponseAsync<T>~8 min
- 04.04Design Records the Model Can Fill~7 min
- 04.05Validate, Repair or Reject~8 min
- 04.06Extract Job Data from Messy Postings~10 min
- 04.07Classification with "Unknown" as a Valid Answer~7 min
- 04.08Batch Processing with Channels and Backpressure~9 min
- 04.09Checkpoint and Solution: The Job Posting Normalizer~8 min
MODULE 05
Evals from Day One
Measure AI quality like you measure code, and improve it step by step with evidence.
After this module you can
- Build a golden dataset and deterministic checks in xUnit
- Use Microsoft.Extensions.AI.Evaluation and know the limits of LLM-as-judge
- Keep a score history that shows every regression
- Raise the normalizer from 75% to 96% with measured, one-at-a-time changes
Videos
- 05.01Why Unit Tests Are Not Enough for AI~6 min
- 05.02Build a Golden Dataset for the Normalizer~8 min
- 05.03Deterministic Checks with xUnit~8 min
- 05.04Microsoft.Extensions.AI.Evaluation: Evaluators and Scenarios~9 min
- 05.05LLM-as-Judge with a Local Model, and Its Limits~8 min
- 05.06Reports, Score History and Response Caching~7 min
- 05.07From 75% to 96%: Improve with Evidence~10 min
- 05.08Checkpoint and Solution: Choose the Model, Check the Full Set~9 min
MODULE 06
Embeddings and Semantic Search
Build a multilingual job search that understands meaning, and measure how good it is.
After this module you can
- Create embeddings with a local model and store them in PostgreSQL with pgvector
- Combine full-text and vector search, and filter before similarity
- Search German and Dutch postings with an English query
- Measure search quality with Recall@k instead of guessing
Videos
- 06.01What Embeddings Are, Visually~6 min
- 06.02IEmbeddingGenerator and Local Embedding Models~7 min
- 06.03PostgreSQL + pgvector with Microsoft.Extensions.VectorData~9 min
- 06.04Records, Indexes and Distance Functions~8 min
- 06.05A Semantic Job Search Endpoint~9 min
- 06.06Hybrid Search: Full-Text plus Vector~9 min
- 06.07Filter before Similarity: Country, Visa, Remote~7 min
- 06.08Multilingual Search: German and Dutch Postings~7 min
- 06.09Checkpoint and Solution: Measure Search Quality with Recall@k~8 min
MODULE 07
Retrieval-Augmented Generation (RAG)
Answer questions from your own documents with sources, and say "I don't know" when the evidence is missing.
After this module you can
- Ingest, chunk and version documents for retrieval
- Return answers with citations that point to the source
- Evaluate retrieval and groundedness separately
- See a prompt injection hidden in a document, live
Videos
- 07.01From Search to Answers: The RAG Pipeline~6 min
- 07.02Ingest Documents: Parsing and Chunking~9 min
- 07.03Metadata, Versions and Re-Indexing~8 min
- 07.04The Answer Endpoint with Citations~9 min
- 07.05Say "I Don't Know" When Evidence Is Missing~7 min
- 07.06Reranking on a Budget~8 min
- 07.07Evaluate Retrieval and Groundedness Separately~8 min
- 07.08Attack: A Prompt Injection Hidden in a Job Posting~7 min
- 07.09Checkpoint and Solution: Ask JobScout about Visa Sponsorship~8 min
MODULE 08
Function Calling and Tools
Let the model call your C# methods safely, and show its work live in the UI.
After this module you can
- Turn C# methods into tools with AIFunctionFactory
- Design tool descriptions and parameters the model uses correctly
- Give tools safe database access, timeouts and budgets
- Stream answers and tool activity to a Blazor UI, and evaluate tool selection
Videos
- 08.01How Tool Calling Works under the Hood~7 min
- 08.02AIFunctionFactory: Turn C# Methods into Tools~8 min
- 08.03Tool Descriptions and Parameter Design~7 min
- 08.04FunctionInvokingChatClient: Automatic Tool Loops~8 min
- 08.05Tools That Touch Your Database Safely~9 min
- 08.06Errors, Timeouts and Tool Budgets~8 min
- 08.07Stream Answers and Tool Activity to a Blazor UI~9 min
- 08.08Evaluate Tool Selection~8 min
- 08.09Checkpoint and Solution: A Tool-Using Job Assistant~8 min
MODULE 09
Agents with Microsoft Agent Framework
Build a career assistant agent with lasting state and guardrails.
After this module you can
- Explain what an agent framework adds on top of IChatClient
- Build a ChatClientAgent with instructions, tools and context providers
- Persist conversation state in PostgreSQL
- Add guardrails and a memory policy, and know when an agent is the wrong tool
Videos
- 09.01From IChatClient to an Agent: What the Framework Adds~7 min
- 09.02Your First ChatClientAgent~7 min
- 09.03Instructions, Tools and Context Providers~8 min
- 09.04Sessions and Conversation State~8 min
- 09.05Persist Agent State in PostgreSQL~9 min
- 09.06Agent Middleware: Guardrails before and after the Model~8 min
- 09.07Memory: What to Remember and What to Forget~8 min
- 09.08When an Agent Is the Wrong Tool~6 min
- 09.09Checkpoint and Solution: The Career Assistant Agent~8 min
MODULE 10
Workflows, Multi-Agent and Human Approval
Build workflows where nothing is saved until a person approves it.
After this module you can
- Model a process as a graph workflow with checkpoints
- Pause a workflow for a person and resume it later, even after a restart
- Measure whether a second agent is worth its cost
- Make side effects happen exactly once with idempotency keys
Videos
- 10.01Workflows versus Free-Form Agents~6 min
- 10.02A Graph Workflow: Read, Check, Review, Save~9 min
- 10.03Checkpointing and Resuming Workflows~9 min
- 10.04Handoff and Sequential Orchestration~8 min
- 10.05Measure: Is the Second Agent Worth It?~8 min
- 10.06Human-in-the-Loop: Pausing a Workflow for a Person~9 min
- 10.07Save, Edit or Discard from a Blazor Screen~9 min
- 10.08Exactly-Once Side Effects with Idempotency Keys~8 min
- 10.09Checkpoint and Solution: Add a Job with Human Review~8 min
MODULE 11
MCP with .NET
Publish your app's capabilities as an MCP server that any AI client can use.
After this module you can
- Build an MCP server with the C# SDK: tools, resources and prompts
- Choose between stdio and HTTP transport in ASP.NET Core
- Test with MCP Inspector and consume MCP tools from your own agent
- Secure an HTTP MCP server with authorization and allowlists
Videos
- 11.01What MCP Solves~6 min
- 11.02Build an MCP Server with the C# SDK~9 min
- 11.03Tools, Resources and Prompts~8 min
- 11.04Stdio versus HTTP Transport in ASP.NET Core~8 min
- 11.05Test Your Server with MCP Inspector~6 min
- 11.06Consume MCP Tools from Your Agent~8 min
- 11.07Allowlists and Tool Output Trust~8 min
- 11.08Authorization for HTTP MCP Servers~9 min
- 11.09Checkpoint and Solution: Publish JobScout Search as an MCP Server~8 min
MODULE 12
Security
Defend an AI feature against real attacks, and keep the defenses as tests.
After this module you can
- Threat-model an AI feature
- Stop the prompt injection from Module 7 and three attacks the system has never seen
- Carry the user's identity all the way to the tool, and keep personal data away from the model
- Turn red-team attacks into permanent xUnit tests
Videos
- 12.01Threat Model an AI Feature~7 min
- 12.02Defend against the Injection from 07.08~9 min
- 12.03User Identity All the Way to the Tool~9 min
- 12.04PII: Keep It away from the Model~8 min
- 12.05An Output Rule, Not an Attack Detector~8 min
- 12.06Rate Limiting AI Endpoints~7 min
- 12.07Red Team Tests as xUnit Tests~8 min
- 12.08Checkpoint and Solution: Attack Report, Before and After~7 min
MODULE 13
Observability
Find out why one answer was wrong, from a single trace.
After this module you can
- Use the OpenTelemetry GenAI conventions in .NET
- Follow one trace across API, agent, tools and database
- Track tokens and latency, and log decisions instead of secrets
- Build an operations dashboard and capture user feedback
Videos
- 13.01OpenTelemetry GenAI Conventions in .NET~7 min
- 13.02One Trace across API, Agent, Tools and Database~8 min
- 13.03Token and Latency Metrics~7 min
- 13.04Log Decisions, Not Secrets~6 min
- 13.05Capture User Feedback~7 min
- 13.06Debug a Wrong Answer from One Trace~9 min
- 13.07Checkpoint and Solution: An Operations Dashboard~7 min
MODULE 14
Performance and Cost
Make the AI pipeline faster and cheaper without losing quality, and prove it.
After this module you can
- Measure the cost of a request, even on a local model
- Use smaller models for narrow steps, and cache responses and embeddings
- Shrink context without losing evidence, and limit concurrent model calls
- Load-test an AI endpoint and protect the gains with budgets
Videos
- 14.01Baseline: Cost per Request, Even on a Local Model~6 min
- 14.02Benchmark Your AI Pipeline with BenchmarkDotNet~9 min
- 14.03Smaller Models for Narrow Steps~7 min
- 14.04Response and Embedding Caching~8 min
- 14.05Shrink Context without Losing Evidence~8 min
- 14.06Concurrency Limits and Queues for Model Calls~9 min
- 14.07Load-Test an AI Endpoint~8 min
- 14.08Checkpoint and Solution: Faster, Same Quality~7 min
MODULE 15
Testing and Deployment
Ship with a CI pipeline that guards quality, and deploy with one command.
After this module you can
- Build a test pyramid for AI: unit, database, recorded and model tests
- Run LLM tests in CI without a GPU, using recorded responses
- Add an eval gate in GitHub Actions
- Containerize the app, choose a production model strategy and deploy with Docker Compose and a smoke test
Videos
- 15.01The Test Pyramid for AI Applications~6 min
- 15.02Integration Tests with Testcontainers~9 min
- 15.03Recorded Responses for Fast CI~8 min
- 15.04An Eval Gate in GitHub Actions~9 min
- 15.05Containerize API, Worker and Models~8 min
- 15.06Production Model Strategy and Per-Environment Configuration~9 min
- 15.07Health Checks, Readiness and Model Warm-Up~8 min
- 15.08Deploy with Docker Compose to Any Docker Host~8 min
- 15.09Checkpoint and Solution: One-Command Deploy and Smoke Test~7 min
MODULE 16
Capstone: Verification and Decisions
Prove the whole system works, and leave with the decisions you can defend.
After this module you can
- Turn acceptance criteria into executable checks
- Run the full suite of evals and attacks, and read the evidence
- Switch to a hosted model with one setting and compare quality
- Use a decision guide for .NET AI architecture, and keep the system up to date safely
Videos
- 16.01Acceptance Criteria as Executable Checks~7 min
- 16.02Run the Full Suite: Evals, Red Team and Load~10 min
- 16.03Full Demo: From a Messy Posting to Matching Jobs~10 min
- 16.04Optional: Switch to a Hosted Model with One Setting~7 min
- 16.05Architecture Decision Guide for .NET AI Apps~9 min
- 16.06Code Review: Known Limitations~8 min
- 16.07Keeping Up: Updating Packages, Models and Prompts Safely~7 min
FAQ
What's the format?
A self-paced video course. You build one real project end to end, and every module ships with a working codebase. Watch at your own pace; access doesn't expire.
How much will it cost?
$59, one-time payment.
When does it launch?
It's in production now. Everyone on the waitlist hears first, with an early-access discount.
What do I need before starting?
You should be comfortable with C# and have built at least a basic ASP.NET Core app — this isn't a beginner C# course. No prior AI or machine learning experience is needed.
You'll need the .NET 10 SDK, Docker and Ollama, all free. Everything runs on local models, so no paid API keys are required. We recommend at least 16 GB of RAM; slower machines can follow along using the course's lightweight setup.
WAITLIST
Get notified when AI Engineering for .NET Developers opens
Waitlist members hear first, with early access and a launch discount.