Speakers

If you use modern FastAPI, you’ve probably written Annotated[...] because the documentation told you to. It works, but what is actually happening inside those brackets?

Before Annotated, FastAPI and Pydantic had a slightly awkward habit: they lied to the type checker. It was a useful lie, but a lie nonetheless.

We’ll see how that trick worked, what changed with Annotated, and how FastAPI and Pydantic turn metadata into dependency injection, validation, and reusable definitions. Along the way, we’ll follow metadata from a type annotation to runtime behavior and see when the same pattern is worth using in your own library APIs.

For most of my career, my job was writing code.

Today that’s a small part of what I do: AI can take care of the implementation. My job now is to formulate the problem for the AI to solve—choose the metrics to optimize and the constraints to respect—then make it fast and easy for the AI to iterate.

This sometimes feels like herding the model: cutting off all the bad routes, so its randomness can only push in the direction of the improvement I want.

In this talk, I’ll review three real-world projects through this lens and propose practical ways to set up feedback for the model.

This is not a software-factory pitch. I still write code, and my review is often the most important constraint, but I don’t think it makes sense to pretend that me writing and reading all the code is the best way to build software anymore.

Luckily, in a world where AIs write the code, the human who formulates the problem is more valuable than the human who wrote the code was a year ago.

Ben will cover the different methodologies used to deliver data at the Space Telescope Science Institute, including streaming database responses, S3 redirects, asynchronous Celery workers, and NGINX.

I was always skeptical about speed in Python, so I assumed the "fast" in FastAPI was about how fast you could build things. But over the years, people across the ecosystem kept finding room to make it fast in the other sense too. Not through one big rewrite, but through small, sometimes surprising discoveries in Starlette, Pydantic, Uvicorn, and the libraries underneath.

In this talk I’ll walk through that story. We’ll start with python-multipart, and how a parser that everyone depended on and nobody looked at was quietly eating your CPU. We’ll look at what Pydantic v2 changed for validation, and what moving JSON serialization into Rust did for responses. Then I’ll share my own experiments rewriting the hot paths in Rust and Zig, including zuvloop and zttp, and be honest about what worked, what didn’t, and where the real bottlenecks turned out to be.

Along the way we’ll cover routing, dependency injection overhead, OpenAPI generation for large apps, and why the "slow" part of your app is often not where you expect.

Finally, we’ll look ahead: what’s already in progress, what’s still on the table, and what the next few years of FastAPI, Starlette, and Uvicorn could look like.