Overview
Pick FastAPI when you are shipping a new API service, you want OpenAPI for free, and you can compose the auth, ORM, and admin yourself. Pick Django when you need the admin UI, the ORM, and migrations the moment the repo exists; the batteries-included story still has no Python rival in 2026. The split is concrete: FastAPI for “API plus SPA or mobile frontend”; Django for “internal tools, content sites, and CRUD apps with a staff portal.” See fastapi for the FastAPI rule set and python for the language baseline.
When FastAPI wins
FastAPI is the right pick for any service that is API-first and async-shaped.
- OpenAPI generation from function signatures: every endpoint has a
/docspage without extra code. Django REST Framework needsdrf-spectacularplus annotations. - Async-native: ASGI from day one,
async defendpoints route through Starlette without monkey-patching. Django ASGI works but the ORM is sync under the hood and async pays in middleware only. - Pydantic v2 validation: types come from the model definitions; request and response bodies are checked at the boundary with zero hand-rolled code.
- Smaller surface to learn: an entire service fits in 200 lines of
main.pyplus routers. Django’s project layout has more files before you write a single endpoint. - LLM agents pattern-match FastAPI well: it is small, declarative, and consistent. Django’s class-based views and managers are harder to refactor with an agent.
- Cold start: FastAPI on Uvicorn starts in roughly 150 ms; Django on Gunicorn plus its app registry takes 400 to 800 ms.
When Django wins
Django is the right pick when the product needs an admin, an ORM, and a story for migrations on the first commit.
- Django Admin: a free CRUD UI over every model. Replacing it in FastAPI costs three to six engineer-weeks; you reach for Retool, Forest, or hand-built React.
- ORM plus migrations:
makemigrations,migrate, fixtures, signals, and constraints all ship together. FastAPI plus SQLAlchemy plus Alembic is the equivalent stack and it is more glue. - Auth, sessions, CSRF, permissions, groups: all in the box. FastAPI users assemble these from FastAPI Users, Authlib, or a hand-rolled JWT layer.
- Server-rendered pages: Django templates plus htmx is a viable full-stack story without a frontend framework. See htmx-vs-react.
- Mature ecosystem: 20 years of packages for SAML, OAuth, payments, search, multi-tenancy. FastAPI’s ecosystem is younger.
- Large team scaling: Django’s conventions cap bikeshedding; new contributors find files in known places.
Trade-offs at a glance
| Dimension | FastAPI | Django |
|---|---|---|
| Style | Function-first, async | Class-first, sync-default |
| OpenAPI | Free from signatures | Add drf-spectacular |
| Validation | Pydantic v2, native | Forms or DRF serializers |
| Admin UI | None; bring your own | Django Admin, free |
| ORM | Bring your own (SQLAlchemy) | Django ORM, batteries included |
| Migrations | Alembic | makemigrations plus migrate |
| Async story | Native, end-to-end | Partial; sync ORM under async views |
| Auth and sessions | Roll-your-own | Built-in users, groups, perms |
| Templates | Jinja2 if needed | Django templates, native |
| Cold start | Fast (150 ms) | Slower (400 to 800 ms) |
| Hiring pool | Growing fast | Very large, stable |
| Learning curve | One day for an endpoint | One week for the full project |
Migration cost
Django-to-FastAPI is a service split, not a port. FastAPI-to-Django almost never happens.
- Django to FastAPI: keep Django for the admin and content models, extract hot API paths into a sibling FastAPI service that shares the same Postgres. Plan one engineer-week per 20 endpoints.
- Full rewrite: a 50k-LoC Django app to FastAPI typically lands at two to four engineer-months; you rebuild auth, admin, migrations, and signals from parts.
- FastAPI to Django: only when the team gives up on assembling an admin. Plan a two-month rewrite to recover what Django gives you on day one.
- Hybrid: many teams run Django for the admin and CMS, FastAPI for the public API, on the same database. The split is durable. See postgres.
Recommendation
- New API for a Next.js or React Native frontend: FastAPI. See fastapi.
- Internal tool, marketing site, or content app: Django. The admin alone justifies the choice.
- ML inference API: FastAPI; async wins for tail latency.
- Multi-tenant SaaS with staff portals and complex permissions: Django.
- Microservice that does one job in 300 lines: FastAPI.
- Bet on long-term Python stability: both are safe; the choice is shape, not survival.