# The Creator of FastAPI's Next Chapter

Sebastián Ramírez, FastAPI Labs | MLOps Podcast | Episode 324 | 1:09:38
Hosted by Demetrios Brinkmann

Source: https://www.youtube.com/watch?v=PFwWstFrHF0
Channel: MLOps Community, now AAIF Live (https://www.youtube.com/@AAIFLive-x1r). Summarised by MLOps Talks.
Page: https://mlopstalks.com/talks/the-creator-of-fastapis-next-chapter
Published: 2025-06-17
Tags: deployment, developer-experience, open-source, product-strategy

## TL;DR
- Sebastián Ramírez built FastAPI after repeatedly struggling to create APIs for machine learning applications, with developer experience as the main design goal.
- FastAPI Cloud is intended to fund the open-source ecosystem while keeping FastAPI fully open source and deployable anywhere.
- Sebastián chooses abstractions when learning the abstraction saves users far more effort than learning and managing the underlying systems.

## Summary
Sebastián Ramírez explains how his machine learning background led him to FastAPI, after repeated difficulty building APIs around computer vision and other applications. Pydantic became central because it made validation, serialization, documentation, and typed developer workflows simple. He then describes why he started FastAPI Cloud after years of relying on part-time work, sponsorships, and a 2023 Sequoia open-source fellowship. The company gives him a sustainable way to fund work on FastAPI and related projects while keeping the framework fully open source. Sebastián also explains his approach to abstraction: a new layer is worthwhile when users can learn it quickly and avoid much greater effort underneath. His examples include SQLModel, FastAPI Cloud, and SDK design. The conversation ends with the practical challenge of managing a large open-source community and gradually trusting a team with reviews, documentation, the CLI, and the product UI.

## Key ideas
### Pydantic made data handling easier to understand and reuse
[02:05](https://www.youtube.com/watch?v=PFwWstFrHF0&t=125s)
Sebastián Ramírez likes Pydantic because it makes data validation, autocomplete, and clear errors simple. Before it became widely known, developers often wrote custom checks for integers, JSON objects, and other inputs because they did not realize a reusable validation tool existed. FastAPI uses Pydantic for validation, serialization, parsing, and documentation. Sebastián also used Pydantic outside FastAPI, including GitHub Actions that turn environment variables into typed models. He says FastAPI helped people discover Pydantic, after which they began using it in SDKs and other tools.

### FastAPI grew out of repeated API problems in machine learning work
[07:33](https://www.youtube.com/watch?v=PFwWstFrHF0&t=453s)
Sebastián got into Python through an AI course and then worked on computer vision before deep learning was common in his projects. His teams repeatedly had to put APIs around machine learning applications, yet the available tools made that work complicated. The team ended up copying his setup because it worked, even though the developer experience was poor. He kept researching frameworks until he found the ingredients for FastAPI. He says his original path into Python was AI and machine learning, although the repeated API problem pulled him into building FastAPI.

### The emoji documentation became an accidental FastAPI signature
[11:37](https://www.youtube.com/watch?v=PFwWstFrHF0&t=697s)
Sebastián explains that the emoji-heavy FastAPI documentation came from an April Fool's joke and a translation route. One available language is emoji, so a URL with the emoji language prefix displays the documentation entirely in emoji. The translation was created by community contributors, and Sebastián says the pull request received more approvals than any other FastAPI pull request. Some users have reported that the documentation was hacked because they reached the emoji version by mistake. He also describes a Reddit joke that treated the emojis as evidence of drug use, which he eventually learned to take as a compliment.

### The open-source fellowship gave Sebastián time for work that needed sustained focus
[19:23](https://www.youtube.com/watch?v=PFwWstFrHF0&t=1163s)
Before FastAPI Cloud, Sebastián supported his open-source work through small sponsorships and part-time employment. He explains that many individual donations of a few dollars do not create a sustainable income, while company sponsorships often need something concrete in return. In 2023, Sequoia's open-source fellowship covered his expenses and allowed him to work full time on open source with little direction. That made difficult projects possible, including FastAPI's support for both Pydantic version one and version two. Sebastián says work like that is hard to complete through scattered evening and weekend hours because it requires maintaining context.

### FastAPI Cloud connects commercial funding with an open-source project
[23:59](https://www.youtube.com/watch?v=PFwWstFrHF0&t=1439s)
By the end of 2023, Sebastián saw companies trying to build a cloud for FastAPI or Python and decided that he could build one with a better FastAPI experience. He wanted to create the cloud for himself as the first FastAPI user, while keeping FastAPI fully open source with all its features. Users can deploy FastAPI wherever they want, and FastAPI Cloud can offer a simpler path for those who choose it. The commercial product gives the company a way to fund continued work on FastAPI, Typer, SQLModel, Asyncer, and the surrounding ecosystem.

### A focused cloud product can remove the burden of general infrastructure
[29:04](https://www.youtube.com/watch?v=PFwWstFrHF0&t=1744s)
Sebastián changed his view on deployment after seeing how much effort Kubernetes requires. He had once encouraged people to install Linux machines, manage clusters, and build their own infrastructure. That advice became less convincing when the alternative was learning Kubernetes or combining several generic cloud products. FastAPI Cloud is intended to handle deployment details so developers can focus on their application and product. He compares this with buying a car instead of separately sourcing and assembling its motor, tires, and doors when your business is not building cars.

### An abstraction is worthwhile when it saves users far more effort than it costs to learn
[37:41](https://www.youtube.com/watch?v=PFwWstFrHF0&t=2261s)
Sebastián says he avoids building a new abstraction until he sees that it can give users substantial savings over learning the underlying system. Users still need to learn a small amount about FastAPI, SQLModel, or a cloud product, but that effort should be far smaller than building and debugging everything by hand. He also looks for gaps that existing tools repeatedly fail to address. This reasoning led to FastAPI after API Star, to SQLModel after other type-annotation-based ORM attempts missed his desired experience, and to FastAPI Cloud after generic deployment systems remained too difficult for FastAPI users.

### Developer experience comes from specific design choices and documentation
[43:29](https://www.youtube.com/watch?v=PFwWstFrHF0&t=2609s)
Sebastián says good developer experience can look like taste, but it usually comes from many specific decisions. For generated Python SDKs, he recommends typed dictionaries for function inputs so editors can provide autocomplete without requiring users to import another model. Pydantic models work well for outputs because users get autocomplete when accessing returned attributes. When building SQLModel, he started with the documentation and examples before writing the implementation. If a feature could be configured in several ways but explaining the priority was difficult, he removed the extra options even when they were already easy to implement.

### Open-source maintenance depends on filtering noise and building trust
[53:56](https://www.youtube.com/watch?v=PFwWstFrHF0&t=3236s)
FastAPI receives many questions, translations, feature requests, and pull requests, so Sebastián relies on FastAPI experts and his team to filter what needs attention. Issues often turn out to be questions or mistakes in a user's code rather than FastAPI bugs. A small pull request can still require checking thousands of unchanged lines and their interactions. He may defer a change when a broader solution would address several use cases, even though that can be hard to explain to the contributor. As the company grows, team members such as Patrick, Alejandra, and Sophie review the CLI, UI, Typer, and FastAPI work. Sebastián still sets the quality bar, but he is gradually trusting them to make more decisions.

## Notable quotes
- Sebastián Ramírez: "The thing is Pydantic made it super simple to validate data and to get autocomplete and clear errors for the data that you are handling in code." (02:05)
- Sebastián Ramírez: "I got into Python to do AI and ML. That's why I got into Python." (07:33)
- Sebastián Ramírez: "When learning that is much less effort than they will have to put to learn the underlying thing, then that's the point when it makes sense." (38:14)
- Sebastián Ramírez: "If you put yourself in the shoes of whoever is going to be the final user, it is much easier to optimize that experience for the final user." (49:04)
- Sebastián Ramírez: "I still review each one of those and make sure that they are good." (58:22)

## Tools & references mentioned
- FastAPI
- FastAPI Cloud
- Pydantic
- Typer
- SQLModel
- Asyncer
- FastAPI Labs
- Sequoia
- Open Source Fellowship
- Docker Swarm
- Kubernetes
- API Star
- Starlette
- Tom Christie
- Sentry
- Astral
- OpenAPI
- OpenAI
- Anthropic
- React
- TypeScript
- Tailwind CSS

## Who should watch
- You maintain a popular open-source project and need ideas for funding full-time work without putting the core project behind a paywall.
- You are designing a Python framework, SDK, or developer tool and want concrete ways to reduce imports, configuration, and documentation complexity.
- You deploy FastAPI applications and want to understand the reasoning behind a dedicated cloud product rather than managing general infrastructure yourself.

## Related talks

- [FastAPI for Machine Learning](https://mlopstalks.com/talks/fastapi-for-machine-learning) (Sebastián Ramírez, Forethought, 52:38)
- [AI Innovations: The Power of Feature Platforms](https://mlopstalks.com/talks/ai-innovations-the-power-of-feature-platforms) (Mahesh Murag, Tecton & Jose Navarro, Cleo & Nikhil Garg, Fennel, 1:05:28)
- [Fast.ai, AutoML, and Software Engineering for ML](https://mlopstalks.com/talks/fast-ai-automl-and-software-engineering-for-ml) (Jeremy Howard, Fast.ai, 57:43)
- [Making MLflow](https://mlopstalks.com/talks/making-mlflow) (Corey Zumar, Databricks, 59:11)
- [Building an ML Platform from Scratch: Live Coding Session](https://mlopstalks.com/talks/building-an-ml-platform-from-scratch-live-coding-session) (Alon Gubkin, Aporia, 1:57:24)