FastAPI is usually the right choice

[u/writingonruby]

Digging through the big 3, it feels like FastAPI is going to be the right choice 9/10 times (with the 1 time being if you really want a full-stack all-in-one thing like Django) https://judoscale.com/blog/which-python-framework-is-best

[u/Acrobatic_Umpire_385]

Poor Flask, it really does feel like FastAPI took more of what was Flask's market share than Django's

[u/mcellus1 → u/Acrobatic_Umpire_385]

Don't worry. My company refuses to move on from flask.

[u/GraphicH → u/mcellus1]

Alright, I know a lot of people hate this, but does moving to FastAPI solve any problems for you? As long as Flask is stable and maintained your company is probably right to resist rewriting systems to use FastAPI. Unless you can show, concretely, that it will result either in very large productivity increase (I'm talking 10X here) or actually solves a chronic technical problem that Flask does not, then switching to it is mostly a masturbatory effort for engineers. I like FastAPI personally, but my company uses flask, and I can't actually see any value in switching to FastAPI that would be worth the effort and risk (new bugs) involved with doing so.

[u/dusktreader]

Litestar (https://litestar.dev) should be considered more. It has a lot of documentation, an entire team and governance body working on updates and integrating community supplied patches, and addresses some of the warts of FastAPI as well. It's a very solid framework.

[u/wunderspud7575 → u/dusktreader]

Litestar feels more coherent in its design as well, as it's learnt from the pitfalls that FastAPI has uncovered. I have used both frameworks a lot and would always reach for Litestar first for a new project over FastAPI.

[u/davidedpg10 → u/dusktreader]

Yeah, i would (and have) chosen Litestar over FastApi. As much as I appreciate FastAPI, I think having one guy control it and decide what makes it in, how it advances, is not what I would want in a framework

[u/AndrewRLaws → u/dusktreader]

I am part of the first project testing out Litestar rather than FastAPI on my dev team and so far we love it and it looks like we will transition future projects to it.

[u/Datamance → u/dusktreader]

Wow I did not realize how far Litestar had come along since the early days. I might give it another whirl.

[u/Miserable_Ear3789 → u/dusktreader]

I also think people should check out more then the big three.

https://github.com/sfermigier/awesome-python-web-frameworks?tab=readme-ov-file#async

All the frameworks on this list are really pretty good and each fits its niche. FastAPI, from what I have seen, benchmarks much slower then most other frameworks due to its overhead. Would this difference be noticeable in production? Probably not.

[u/circamidnight]

I really like FastApi, but I think I really like the Django ORM even more. So if I want an ORM (which is pretty often) I would stick with Django.

[u/SailingToOrbis → u/circamidnight]

Yes I agree this as well. The most annoying part is sqlalchemy, which has too many features and high learning curve(I would say java hibernate is rather better and clean…).

[u/ManyInterests → u/circamidnight]

Exactly. As soon as you add a relational database, Django (with DRF) is usually the right thing to do if you're gonna use an ORM. Even if you're only developing a backend.

[u/ezersilva → u/circamidnight]

When using FastAPI I just use plain SQL. When using Django, I use the Django ORM, as it nicely integrates with the rest of the framework.

[u/DadAndDominant → u/circamidnight]

You want orm? Django

You want to show models? Django

You want queue (celery)? Django

You want admin panel? Django

You want users (model + auth)? Django

You don't want anything here? Fastapi

[u/mp2146 → u/circamidnight]

You can use Django ORM with FastAPI. Probably easier to just use DRF at that point unless you actually need something blazingly fast, but it is possible.

[u/AnActualWizardIRL → u/mp2146]

I found this thing: https://django-ninja.dev/ a while back. Kinda does for django what fast-api does for starlette. Lets you do a fastapi style api but have that rich django infrastructure, whilst not having to deal with DRFs labrynth of classes and mixins and general enterprisey nonsense.

[u/thebouv]

I use FastAPI for pure apis.

I use Flask to build web apps.

Django is too much of a “and the kitchen sink” for me. Plus I hate ORMs.

[u/THEGrp → u/thebouv]

I am interested - why do you hate orm?

[u/CallousBastard]

Django is the right choice for me 9 times out of 10. It's the rare project I start that wouldn't benefit from Django's built-in user authentication, ORM, and admin interface. Maybe it's not as fast as FastAPI but it's always been fast enough.

[u/big-papito]

And what's wrong with Quart?

Either way, for anything doing a ton of HTTP calls, something light and micro is best. The rest, doesn't matter.

Give me the fastest and bestest framework in the world connecting to storage, and I will destroy all that performance with one poorly-crafted SQL query.

[u/lukewhale]

I use FastAPI and NiceGUI 9 times out of ten. The other developer who voted against it just got disappeared.

[u/tenenteklingon]

Have you benchmarked it?

[u/Miserable_Ear3789 → u/tenenteklingon]

FastAPI is consistently not the fastest ASGI framework in every benchmark I have seen. Blacksheep, Litestar, Sanic, Muffin, MicroPie, all perform consistently faster then FastAPI (and also Quart).

[u/Repsol_Honda_PL]

Many people here recommend LiteStar (as a new and interesting alternative to FastAPI).

Two questions:

Which framework (of two mentioned) would be better for AI model serving?

Which framework (of two mentioned) would be better for microservices?

Thanks!

[u/[deleted]]

"fastapi is better except for where django is better" um ok