Speakers & talks

Your team has exciting plans. Your users would prefer a quiet afternoon.

At Polar, we wanted to keep both happy: one FastAPI application, the same URLs, and date-named API versions selected by a header. We built a versioning workflow where endpoints and schema fields declare which versions they belong to and each supported version gets its own OpenAPI schema.

Then we took it all the way to our Python and TypeScript SDKs: our generator packs every supported version into its own typed module, so updating a package doesn’t have to mean upgrading the API. Versions can live side by side, and type checkers become helpful migration companions.

A practical story about making API evolution friendlier, both for the team shipping changes and the developers receiving them.

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.

Get the bleeding edge tips and tricks to develop FastAPI apps for AI, using coding agents, directly by Jason, from the Codex team at OpenAI.

FastAPI made it remarkably easy to build APIs. But what happens when the client on the other side is an agent?

It turns out agents and AI applications need many of the same things as the web and mobile applications we've been building for years: fast access to state, caching, rate limiting, real-time updates, event-driven communication, and coordination across services. They also introduce new challenges: responses that take seconds to generate, arrive incrementally, trigger other work, or need to continue even after a client disconnects.

In this talk, we'll look at these patterns through real applications built with FastAPI and Redis. We'll start with a customer architecture for streaming LLM responses using FastAPI, WebSockets, and Redis Streams, and use it to explore a broader idea: many of the building blocks we already know from modern application development become even more important when building agents.

Along the way, we'll see where Redis primitives such as Streams, caching, rate limiting, and shared state fit into the AI application stack—and where agents create genuinely new requirements.

Finally, we'll look at how the new official FastAPI Redis SDK brings these patterns directly into FastAPI, making it easier to build applications for both human and agentic clients.