# 21.03 Web API 200

> APIs in production: performance, observability with OpenTelemetry, hosting, and integration patterns.

Format: 3 days · instructor-led
Builds on: 21.02

Getting an API working is the first half of the job. The second half starts in production: it's slower than it should be under load, something fails intermittently and nobody can see why, another team wants to depend on it, and it has grown large enough that changing it feels risky.

Web API 200 is about that second half. We instrument APIs with OpenTelemetry and use what it shows us to find and fix real problems. We look at what the operating system and the container are doing underneath your code. We design for different kinds of consumers, host and test APIs the way they actually run, integrate with other services without tying their deployments together, and move slow work out of the request path.

## Who it's for

C# developers who have built HTTP APIs with ASP.NET Core and have some project work behind them, ideally after [Web API 100](/21.02-web-api-100/). You should be comfortable with CI/CD, configuration management, and containers.

## How it runs

Three days, live and online, with the current release of .NET. Lecture, a lot of "code with me," and short practice exercises, plus two multi-hour labs where you put it together on your own. There's time every day for questions and one-on-one code review. Testing in this course focuses on testing against backing services in isolation.

## What you'll be able to do

- Instrument an API with OpenTelemetry logs, metrics, and traces, and use them to find and fix defects.
- Troubleshoot and prevent common API problems, from performance issues to unreliable networks.
- Explain how threads, processors, and memory affect your API, and what changes when it runs in a container and scales out.
- Design an API for open consumption or for a known consumer, and know which one you're building.
- Host and test an API the way it runs in production, including in the pipeline with `WebApplicationFactory`.
- Use a reverse proxy (YARP) to add resiliency and create seams for breaking up a large service.
- Integrate with other services through RPC, and verify those integrations with contract tests.
- Improve response times with background processing, using a transactional outbox to keep it reliable.
