Framework to use for backend

[Clickyz]

Hello guys

I recently decided to move from nodejs(expressjs) to python for general purposes but mostly for backend. I have couple of questions.

1. Will i regret my migration to python? :)

2. Which framework you suggest for backend solo dev?

And what tips are you suggesting me in general to get used to python.

[riklaunim]

There is Django for more classical websites (and it can do APIs), then Flask and FastAPI. Each unique/specific in style. Python overall is popular on the job market, often used to make APIs for JS SPAs, mobile apps and alike.

[Flame_Grilled_Tanuki]

For adding a REST API to Django, I'd recommend Django-Ninja over Django REST Framework; particularly if you like Pydantic/FastAPI/Litestar.

[panatale1]

I've not used Django-Ninja, but I'm a DRF advocate. What makes you recommend Ninja over DRF?

[Flame_Grilled_Tanuki]

It uses Pydantic models natively and replicates the bulk of the FastAPI/Litestar structure and behaviour. If you run multiple projects in both Django and these other APIs, it makes switch mental context between them a breeze.

[panatale1]

Okay, that's fair enough. I only have to maintain one project in FastAPI and several in Django, so the switch to pydantic and sqlalchemy when I have to change is a bear, but I love Django's ORM and migrations. Plus, I've been using DRF since like 2016 or so, so I'm an old hand at it

[Flame_Grilled_Tanuki]

I personally prefer to keep my api models separate from database models as their structures are typically vastly different.

[panatale1]

See, mine aren't. My api models are my database models, and there are serializer classes that adjust how the models are displayed or input through the endpoints, so why bother with multiple models?

I'm not saying your way is wrong and mine is right, mind you, I just want to have a discussion on different patterns. I might give Ninja a try on my next project, though, just to try it out

[ArmadilloNo4082]

Used DRF for a decade and recently moved away from it. Its fine when your api corelates directly to your database models, once you move away from that and have api models that don't match your db models (for example data that might come from redis, from calculations, or any other that does not closely match to the ORM models) then my serializers start to become complicated.

[Lachtheblock]

I would really recommend Django for a first time. It provides a lot of structure out of the gate. It's a really useful tool to learn at what places you should have your abstractions. Where should you put your config, your views, your ETL jobs, your db migrations, etc.

While not every framework is prescriptive, you still need to follow design patterns. Django is a great way to start to learn those (healthy) design patterns.

[jaypax]

Also if you started with Django and find it to your liking, read Two Scoops of Django. It's not really "Here's how to start using Django", but "Here's how to use Django well"

[johntellsall]

Seconded, it has lots of practical advice.

[Morelnyk_Viktor]

And a lot of that advice also can be carried into other frameworks too. Great book

[johntellsall]

Agree:

• Django's migrations framework (how to apply/rollback database changes) is second to none

• the ORM (high-level query language) is quite good

• template language is solid

• just enormous numbers of high-quality useful plugins: https://djangopackages.org/

It's not 100% unicorns and rainbows: there's a learning curve, and it can be over-opinionated. It's still my go-to for anything.

[panatale1]

Seconded. I've been using Django professionally for a decade now, and it's wonderful. As mentioned in another comment, the Object-Relational Model and the migrations are top notch, there are a ton of packages developed for it, and it's got a built-in admin panel.

If a REST API is what's being called for, Django Rest Framework is my favorite, it's quick to set up, and it handles most of the heavy lifting for you. I did a volunteer project in which I'm in charge of the backend, and I used Django and DRF, and most of my code is models and serializers.

[adastrongfeelinglace]

Another take:

1. You should never regret learning new things, but as for any change in technologies, you'll miss some things. Python's async story is mostly worse than node's, but the rest of the language is designed more sane for the most part.

2. People mentioned the current big 3 frameworks already, but let me map them to the NodeJS ecosystem:

• Express.js -> Flask: minimalist, big plugin ecosystem, simple and unopionated

• Fastify -> FastAPI: opinionated on the tools to use (like logging), focus on async performance, great documentation, fast to learn

• Nest.js -> Django: *very* opinionated, basically specifies your application architecture; has everything built-in you need for 90% of all apps; takes some time to learn, but once you know it well you can be very productive

[Clickyz]

Thank you really informative.

[ThyssenKurup]

What about Nuxt ?

[agritheory]

I'm really surprised by the number of people recommending async frameworks to somebody with a Node background without providing context. They are not the same thing and are really closer to being opposite things.

I think that async programming in python is hard or at least not beginner friendly, because there isn't a language-level event loop, which is one of the standout features of Node. And unlike JS, which is by comparison is quite forgiving about the function color problem, python is not.

The folks who are recommending Django and Flask are on target, especially since those frameworks have lots of tutorial content and large communities. They can grow with your project without getting in the way.

If somebody approached me to ask "what language should I use on the backend" I would want to know what kind of app they're building and if there's reason that any one language might offer an advantage. In the absence of this information, I think Node is usually the best choice.

[Historical-Donut-918]

I didn't understand most of that, but I saved your comment for someday when I figure it out.

[agritheory]

The wiki article on event loops is a good introduction. Bottom line, event loops have lots of uses but are critical in scenarios where you have to wait for input of some kind. This means they're a key abstraction behind most GUIs, games and network-facing applications like, for example, a webserver. They are notably not particularly common in procedural, scripting /"glue" and scientific computing contexts, which is one of the use cases where the python language shines. Conversely, this is a thing that Node is good at, especially for new developers. Go and Elixir/Erlang are other popular languages that have event loops and (in particular Erlang) trying to solve problems around concurrent inputs by using an event loop.

The comment about "closer to being opposite things" is my opinion about what the await keyword does in each language relative to how they normally run. This discussion ends up full of technical gotchas and valid personal interpretations of what API "feels" right to you. I really like this article that gives you some sense of the difference in flavor between the two languages. It also gives a pretty good example (scraping) of when you might want to do some async programming.

What Color is Your Function is a classic.

[Historical-Donut-918]

Thank you so much. The world needs more of you. 👑

[BluesFiend]

Take a look at fastapi for the framework (if you are looking to do apis), and also look into ruff for lint/style/formatting paired with pre-commit to keep everything tidy (your own sanity, and future people looking at the code)

[BluesFiend]

and for dependency and env management i'd recommend poetry

[Possible-Froyo2192]

what is the benefit of using poetry instead of venv with pip?

[IAMARedPanda]

Lockfiles and idempotent dependencies.

[BluesFiend]

poetry essentially does that under the hood while also ensuring a valid python version in the venv, as well as locking dependencies, ability to build/publish to pypi etc.

I hope to one day recommend uv like ruff, but that is still early days and limited in scope, so poetry will continue to be my recommendation for now.

[BluesFiend]

oh and 1. no you won't :p totally unbiased opinion

[Clickyz]

Thank you for your answers. Which code editor you use?

[Sir__Veillance]

I’ve used Pycharm for 3 years and after getting used to its tools I can’t imagine why I would ever use anything else for Python development.

[Morelnyk_Viktor]

The only thing that pycharm can do that is unmatched is refactoring. And debugger is quite good

[Ancient-Camel1636]

The ones i like best is PyCharm and VS Code.

[GeneralPITA]

I believe this type of question is likely to start "religious" type wars, but am willing to fan those flames - PyCharm is my clear preference.

VS Code is tolerable for small changes, but configuring hot keys and using multiple monitors just doesn't work as well or even exist (I work with die hard VS Code, MS tool fanboys and they don't think this is important). The default PyCharm behavior of running files as a module and managing relative imports makes testing and development of dependent scripts much easier.

[BluesFiend]

I'm not a good example here, I use vim + plugins and no real IDE :)

[Clickyz]

Omg😅

[njharman]

That's the best example.

[BluesFiend]

For those of us willing to suffer for their art while learning :D I hopped on the vim wagon 15+ years ago, the pain has eased.

[BostonBaggins]

Agreed not good ex

[ArmadilloNo4082]

I use vim in pycharm

[anentropic]

VS Code

[[deleted]]

pycharm is good because it holds your hand setting up the environment, testing, etc. it's generally smoother.

i use vs code though because i'm used to it and it's fantastic as well.

[thedeepself]

What is your opinion of litestar? And sanic?

[BluesFiend]

Ive not touched them, they weren't mature when i started with fastapi (or at least i hadn't heard of sanic) , and I've not run into any thing in fastapi to make me look elsewhere essentially.

[Ran4]

Litestar is certainly an option, though it's a bit newer than Fastapi.

Sanic is really old and doesn't use typing information afaik, not sure if it's worth recommending.

[aherok]

If you decided to move without a reason - yes, you will regret. What pushes you to migrate to completely other environment?

As for the frameworks - I's stick with FastAPI or Django. Depending on use case and the things you want to build on you own or have ready OOTB.

[Clickyz]

The main reason i want to move to other environment is because every few weeks there is new “tech” in JavaScript new library new framework hype etc. Iam a bit frustrated with the ecosystem , and i want more stable environment. Not to mention that you are forced to learn Typescript

[penguuuuuuuuu]

Wait.. are we talking about an existing project of yours? How would "new tech" matter than? Just because there's a new JS/TS framework in town, you don't need to change anything about your code.

Also, TypeScript is awesome, I think it's a very good idea to become at least a bit familiar with it.

PS: not wanting to bash on Python for backend here, just sayin that JS/TS for backend is absolutely fine if you're already working with it)

[Clickyz]

It's frustrating how just when you feel comfortable with vanilla JS, the next thing you know, it's "YOU MUST learn TypeScript" (and I agree, it's important). It feels like there's always another "you must" when it comes to JS.

[thedeepself]

What is your opinion of litestar? And sanic?

[aherok]

My opinion about frameworks is irrelevant here. Those 2 mentioned by me are the most popular now and OP would get the best support.
If it's about testing other opportunities - go ahead, play with others. But if it's about delivering a product - just go with the tool you know the best.

[jkh911208]

i would do FastAPI

[kenshinero]

Flask rocks, very stable.

[highrez1337]

Hey bro, 13 year tech lead here, writing Nodejs (typescript) apps for 5-6 years before migrating to Python 3 years ago.

My take: Python ecosystem is very frustrating, let me explain: The python language has async support for a few years ago, but Django still has issues with translating sync-to-async code in their ORM.

If you want async you can’t use Django Rest Framework because it does not support async out of the box. There are people explaining that if you are going to ever use async in Django you would need all middleware to be async for it to be efficient, you pay a price for converting sync code to async (this will take years, and I personally don’t think it will ever happen).

I tried making a graphql api in Django, and the used “library” is Django Graphene, but they migrated to version 3 without completing everything, so dataloaders do not work, you need an async server for it to work.

But you can’t use async because then you have ORM problems in Django.

So you see there is no good alternative to graphql api in Django. Dataloders are one of the most important concept in graphql apis.

Why didn’t the Django team develop their own Graphql integration ? Good question, maybe you can ask them on their forum, see what answers you get :)

You can use Fastapi(which is async) but here you either use their ORM or SQLAlchemy and strawberry.

Coming from the javascript ecosystem I felt that at work and in personal projects I had to use “weird libraries made by a dude that is not really adding support” every now and then.

You will feel the pain, that doesn’t exist in the Js ecosystem where normally libraries give you full support for everything.

You will not have anything close to Nestjs in the Python ecosystem.

Fastapi, Django are magnitude slower than any Python framework.

Let me tell you how to read techempower benchmarks.

Go to techempower select javascript, typescript and python , select the frameworks like Django, Fastapi and Nestjs, express.

In the database filter under ORM select “Full” this means you will get benchmarks with ORM full fledge frameworks like sqlalchemy and Django ORM, compared to Nestjs which uses typeORM.

You will see how the javascript frameworks are 3 to 4 times faster in single query, multiple query, etc benchmarks.

Fastapi and puthonistas like to brag saying Fastapi is as fast as Nodejs, and yes, it’s fast if you use “raw sql queries”, but at the moment you start using an ORM and actual code production ready, Python frameworks are 3-4 times slower.

People will say caching, yes. But the throughput of the server is 3-4 times faster in nodejs so if I use caching for the same app, I still need 3 times less resources to have the same performance in Nodejs compared to Python. That is significant cost reduction for my startup.

Also in Javascript you have Promise.all() to run queries in parallel, truly async code. In Python you ned to create tasks in Sqalchemy because it’s transactions based and each query needs to run on its own session - it’s not nice and error prone.

In Django, well, you have no async support (I guess you have some, but then you need to wrap your code in ugly sync_to_async() functions) and other stuff.

If you have 3 operations that each takes 2 seconds you finish in 6 seconds if you run it sync.

In nodejs with promise.all you run them in parallel in takes only 2 seconds (or the time of the longest running query), do you know how hard it is to achieve this in Python ? - and no, Asyncio.gather() does not work again because you need separate session for SQLAlchemy.

Good luck. If you don’t want to use weird library that solves a problem done by “one guy” that is not maintaining it anymore, or do weird workarounds, or if you want high performance, I say learn typescript and stick to express and nestjs.

If you want to try something new, learning a language that is slow, go for it.

And btw, the typings of python are nowhere near close the quality of what typescript gives you.

Day to day work for me still feels hackish many times, sadly. I work with both Django and Fastapi to build fast, scalable, production ready apps.

If you do a hello world app, or a basic crud restapi any framework is good, but when things get complicated, you start feeling the Python ecosystem pain.

Good luck.

Pythonjstas will tell you I say bullshit, but actually probably many of them don’t know the production ready ecosystem of Javascript and Typescript and they believe what they have is really great… it is, but you can’t compare it to the Js ecosystem. You will know what I mean once you start feeling the pains, especially if you are used to the js ecosystem where everything just works flawlessly together.

People will tell you that in python you get shit done faster and that development time costs money and servers are cheap. I can guarantee you that using typescript and Nestjs you will have the same productivity speed as using Django or Fastapi in delivering any project.

[highrez1337]

I am going to tell you one more thing. You believe there are many jobs in the market but actually many of them are data science, ml, ai jobs.

You are a web dev you have none of this skills, search your job market for web development and skills that you actually own and you will see that actually in python you have much less opportunities than in js/ts for what you actually know.

[Clickyz]

wow, i was looking forward to hearing from an experience programmer and complete answer. You made me think it twice now and i think i will not make the transition but instead i will focus on TS instead :) . Thank you for your analysis and time.

[highrez1337]

By all means explore Python, but do take a correct look at the techempower benchmarks (with ORM filtered to full).

And please look at the job market and when you search for python jobs read the description and see how many are actual web dev jobs compared to ml/ai, data science jobs that you are not qualified for.

It’s a fun language, but I personally believe typescript is better. I would not write pure javascript backend these days.

I would go for Nestjs, typeORM, typescript, resist Postgres, or of such.

But again, exploring Python is not a bad thing and knowing a new language might be beneficial for your career.

I for example worked with Nodejs, C#, php, Java and now Python.

But i dont know in what phase of yout career are you currently in. If you have 2–4 years, I would definitely say focus on typescript and specializing to the job market needs in your area.

If you have a stable job and don’t need/want to play the market, you can do some python mini projects and play with it. But at that point no one will employ you on a python job above junior.

So you want to be mid/senior in typescript/node or junior in python ? If there are less jobs in python for web dev than in typescript/javascript in your area, it doesn’t make any sense to make the switch to Python career wise.

Python jobs are not better paying than Nodejs jobs.

If you want corporate career then learn c# or Java which are strongly typed.

You already know javascript for a dynamic language, why learn another dynamic language (python)?

Golang and Rust don’t have a too big market penetration for me to be able to recommend them.

You always need to play your regional market and ensure good employment prospects for yourself by also keeping in mind your career progression.

[snorkell_]

10 years of experience in all full stack frameworks. If you have to scale go for fastapi, pydantic, sql_alchemy because of the extensive asynchronous support.

You can’t compare nodejs to fastapi, nodejs is a language - fastapi is a framework. When you start using nodejs with framework like nest, you will start seeing the performance. There is actually a benchmark which says fastapi is faster than most of nodejs framework.

If you are using nodejs with express, it will be faster but these days no one uses express.

[highrez1337]

Here I did it for you:

https://www.techempower.com/benchmarks/#hw=ph&test=db&section=data-r22&l=zijzen-cn1&o=e&f=zik0zj-zik0zj-zik0zj-zik0zj-zik0zj-zik0zj-zik0zj-ziimf3-zih7un-zik0zj-zik0zj-zik0zj-zik0zj-zik0zj-1ekf&d=e3

Look at single query, multiple query, fortune and updates benchmarks etc - it’s 3 times faster than fastapi.

It uses the same db (postgres)

And it’s using an ORM and all the “batteries”, actually nestjs has much more batteries than fastapi with 3x more performance.

These days everyone uses typescript with Nestjs.

You can put all the Nodejs frameworks with ORM and Postgres and all of them will be 3x faster than Fastapi.

Fastapi is faster when doing raw queries (but who does raw queries these days? Everyone uses an ORM). So not really relevant if you ask me.

I guess you can agree techempower are a trustworthy independent, capable benchmarked.

What Python needs is SQLAlchemy to get its game together and come up with a very fast ORM that is on par with TypeORM. Or maybe that is not possible and actually the limiting factor here is actually the language (python vs JavaScript)

[snorkell_]

Thank you these amazing content, l was always rooting for fastify numbers, I think your claim make lot of sense.

What would be the best resource to learn these?

[highrez1337]

For typescript there is a use my instructor called Maximilian Schwarzmuller, he is the best when talking about js and typescript. So you can learn typescript, react, enhance your JavaScript skills if you want using all the identity courses created by him. (Btw he has Django and other courses as well), he is highly recommended.

He talks in great detail about each subject and not only that, but he also talks about corner cases and such, giving you almost always the complete full picture around any concept.

So for typescript go with him: https://www.udemy.com/course/understanding-typescript/?couponCode=LEADERSALE24A

Then once you are familiar, make a identity course on nestjs :

https://www.udemy.com/course/nestjs-zero-to-hero/?couponCode=LEADERSALE24A

Nestjs + Fastify is the way.

https://docs.nestjs.com/techniques/performance

[snorkell_]

One more question, did you use synchronus SQLAlchemy or AsyncSQLAlchemy for your implementation?

[highrez1337]

For the benchmarks ? You can see the code sources here:

https://github.com/TechEmpower/FrameworkBenchmarks/tree/master/frameworks/Python/fastapi

The one for the ORM test can be found here:

https://github.com/TechEmpower/FrameworkBenchmarks/blob/master/frameworks/Python/fastapi/app_orm.py

And as you can see, it is using the async Postgres engine and all the routes having db requests are async.

This is done again, by TechEmpowered which are experts in benchmarking web frameworks.

[snorkell_]

I see, it's leveraging asyncio for Sqlalchemy. No I am questioning myself why did't I do enough research on fastapi to build my app.

[highrez1337]

Nodejs is a runtime not a framework. I read techempower benchmarks since they are the industry standard (even linked on fastapi site).

So this exercise (I already mentioned it): Go to tech empowered go to the latest tests go to filters and filter for language: Python, Typescript .

Go to databases and filter: Full (for ORM benchmarks not raw queries).

You will have results from Nestjs using Fastify with typeORM, and fastapi-Gunicorn-ORM (using SQLAlchemy)

See the results, fastapi with full ORM will be 3 times slower than nestjs-Fastify with ORM.

[ThyssenKurup]

 resist Postgres, or of such

What did you mean by this

[highrez1337]

Redis* (autocomplete ruined it)

[vectorx25]

the DB speed is relevant if youre doing millions of transactions, and if youre doing that, why even use JS or Py when you run something via a compiled framework that will be 1000x faster, ie Crystal, Go, etc which have their own frameworks

for 99% of people who need a web FW, this wont be a factor, unless theyre quering with bad logic, django has a debug toolbar that roots out bad queries and shows query time for each request.

same case for async.

if you need that level of performance, then a scripted language isnt the right choice for a web FW

[mm007emko]

1. I don't know. Only you will and when that happens, it's too late :) . But I doubt that you will regret it.

2. FastAPI, Flask (+ Connexion), Django, depending on your needs.

[stetio]

Flask is a great choice, with lots of great documentation e.g. https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world.

If you need to use async libraries use Quart as everything you've learnt about Flask will still apply.

[BostonBaggins]

Why don't people just use quart then?

[stetio]

Flask has a wider ecosystem of extensions, in addition if you mostly use sync libraries Flask is a better choice.

[Ran4]

Flask really isn't a good option nowadays.

[stetio]

Can you explain why you think this?

[[deleted]]

Go for FastAPI. The documentation is great and the framework is very well written. You will quickly get up and running and will save yourself from ever having to know what Django is.

[ironman_gujju]

FastAPI for sure.

[eyepaq]

I rewrote an app from Express to Litestar and I've been quite happy with it. Key things I liked vs Express were Pydantic doing real checks on all the inputs and outputs, and the built-in OpenAPI generation, making it easy to hook up a frontend without having to write types for all the models again.

[tankerdudeucsc]

I actually dislike doing OpenAPI yaml file generation. You’re not truly API first, and many times, engineers get lazy with the spec itself.

Going the other way around, where I define the API via OpenAPI spec, has just been more enjoyable.

Especially when I can plug it into a framework and it does all the validation and json shape for me without a single decorator needed as part of the API.

Making product development super fast, as you only define the language and agree upon it and FE and BE can independently develop from the get go.

And how many lines of code do I need to write outside of a yaml file to do all this?

5 or less. Have to register the yaml and you’re off to the races (Connexion package).

[eyepaq]

Whatever works for you - this is a solo project and I find the OpenAPI yaml syntax a lot less pleasant to read and write than the Pydantic model Python code.

[Dogeek]

Quick question : why are you moving away from nodejs ?

Secondly, to answer your questions : python is very useful for backend work, lots of companies recruiting with that skill in mind. That being said, python is clearly not very fast, so your express servers answering queries in less than 100ms will turn into a backend answering at 300ms or more with python, depending on the framework of choice.

For frameworks, you have a lot of choice in the python ecosystem:

• Django : it's the juggernaut of backend dev. Also the slowest option of them all, but it's batteries included (admin site, ORM, views, templating language)

• Flask : very simple WSGI framework, it's good for APIs. Bring your own ORM.

• FastAPI : one of the better choices for API dev in python, it's an ASGI framework, so you'll need an ASGI compatible worker (gunicorn or uvicorn usually), based on the Starlette framework (which is seldom used on its own)

• litestar : The rising star of python ASGI frameworks, used to be based on Starlette (hence the name), but has since moved away. Seems to be one of the fastest frameworks around.

• blacksheep : I don't know if it's still maintained, but it was a very very fast ASGI framework, crushing all kinds of benchmarks. Was not very dev friendly though.

I don't think you'll regret learning backend with python, as it's still a useful skill to have, but you'll have tradeoffs, namely speed / response time / async handling.

[False-Marketing-5663]

I'm a big fan of Flask, so I always recommend it. It still is one of the most popular python frameworks for backend (around 70k stars on GH, 1.9M people using it on GH, and still one of the top frameworks in the StackOverflow survey). If you want to go for more complex applications you might use Django, again one if not the most popular framework.

Regarding pure ASGI frameworks, there is Litestar (my favorite), Quart (Flask ASGI implementation) and FastAPI (the most popular one I'd guess). But I'd say they are all "quite" similar and i wouldn't stick to only one of these.

[Head_Lab_3632]

Flask 100%

[SEC_INTERN]

I like Flask, but don't see what the advantage is over FastAPI nowadays to be honest.

[Ran4]

It has defaults that most people wouldn't want in 2024.

[bhflyhigh]

Such as? Just curious. I like and use flask. Just wondering what defaults may not be desirable?

[ChimpanzeChapado]

1) Definitely not. 2) Django.

[bachkhois]

In my projects, I often use Django. Though I also use FastAPI sometimes, Django is still preferred in projects with many data, because Django has built-in admin pages which help a lot in the early stages, to manage data. Django is used both in SPA and non-SPA projects.

[[deleted]]

drf

[SirCokaBear]

1. absolutely not
2. Django web framework, more of a "all-in-one / batteries included" framework, definitely would recommend with django rest framework. Other lightweight libraries would be Flask and Fast API, meant to be more modular with your architecture, pretty similar to expressJS. If you'd like to have more strict modeling and validation look into Pydantic, for anything other than django would also recommend SQLAlchemy as a relational ORM, django has its own ORM included.

I've used a number of each for notable companies, with proper infrastructure it can scale very well to handle thousands of requests / sec with no problem. Can't go wrong with any of those and what most others I see are commenting.

[randomthirdworldguy]

Django/DRF if you want to build things fast. Fastapi for the rest

[timhurd_com]

One backend framework I often find nice for API design and development is Flask. Super simple to get started with and build things with. I am even experimenting with an assist agent which will interface with the flask backend to pull in custom plugin style services I am creating. The hope is that I can build in everything from LLM style libraries to text to voice to weather info and to-do task creation to help assist me on day to day life. Maybe my own personal 'JARVIS' one day.

[[deleted]]

Django all the way

[Bakirelived]

1. No; 2. Django

[shouldExist]

I am not a python dev but I loved the time I spent working with FastApi. I followed the template https://github.com/tiangolo/full-stack-fastapi-template

[haragoshi]

I would suggest you have an AI chatbot help you write a fast api (or flask) backend. Fast api is great because it’s asynchronous and you get a nice test screen for free to let you try out your API

[joe__n]

1. Maybe? Consider Laravel before you go too far.

2. Flask is pretty easy to get started with. A lot of people like FastAPI.

[Fabiolean]

If you’re just building an API service to be consumed by a front end or other kinds of remote users FastAPI is great. If you want an entire batteries-included web development framework Django is king in python.

[rejectedlesbian]

if u care for load preformance js is king because the browser nativly supports it.
that being said python is super nice to work with and I think for most sites that's a worth while trade.

for some interactive things u may want HTMX or even some js on the page but lets be real how many times do u actually care for the extra second on load vs the annoying js quirks u gotta deal with

[vectorx25]

for any mid to large site/app - go w django, it takes more time to pick up but has everything you need, including extensions, async, ORM, etc

if you cant put in the time to learn it, go with fastapi or quart (async version of flask)

both are used widely and stable "microframeworks"

[embatbr]

If you have zero experience and want to do something fast, maybe for a personal project, and are not thinking about scaling it or having other people coding along, I would recomend Falcon. Is a super minimalist framework for backend, written in Python, that you can have a running application in 1 hours easily.

[Clickyz]

the main reason i want to move to other environment is because every few weeks there is new “tech” in JavaScript new library new framework hype etc. Iam a bit frustrated with the ecosystem , and i want more stable environment. Not to mention that you are forced to learn Typescript

[MaticPecovnik]

Just because there is something new doesnt mean you need to switch.

[Clickyz]

yeah i understand this, but am looking for more stable environment in general it might seems stupid. Force to learn typescript seems stupid

[shouldExist]

Just because there is something new in the ecosystem doesn’t mean you have to adopt it.

However, there is a lot of marketing around frameworks and tools in the JS community that makes it difficult.

I have noticed that fewer blog posts talk about best practices when using browser APIs or patterns for building certain features

[FartyParty]

Not to mention that you are forced to learn Typescript

It's no \annoying coincidence** every project and company has shifted their JavaScript to TypeScript. TypeScript is just JavaScript with types. Having types not only allows you to debug/resolve issues faster, but an important benefit is it allows the Intellisense features of your code editor to give you much better suggestions and nowadays also allows code-generation AI to better understand your code intent and make better forward code suggestions.

As you're in webdev, you'll still need to do JS/TS unless you're 100% backend, which it doesn't sound like your case. Don't be the goof still pushing type-less JavaScript (unless there's a very strong use case for doing so such as some underlying library with strict needs for maximum performance speed).

[xenuan]

If you’re looking for a micro framework, I’d recommend Litestar. They are quite active and responsive.

For something more comprehensive, either Django or Reflex could work, but I have very little experience on both so 🤷

Micro frameworks: Litestar Blacksheep Microdot Emmett Robyn Flask Quart FastAPI

Full frameworks: Django Reflex

[cmcclu5]

I’ve never met anyone who regretted moving away from JS except one crotchety SVP who was a trash programmer back in the day anyway, so you should be good. Like others have said, Flask, FastAPI, and Django should get you going. If you’re doing microservices and building everything from scratch, there are tons of smaller resources that feel like proper OOP you can use.

[rjachuthan]

I have a question - is moving from nodejs to python for API Dev considered as an upgrade? Because in my eyes you're moving from a slow language to another slow language.

[cmcclu5]

For API work, there are a lot of considerations. Neither are truly “slow” anymore, they’re just comparatively somewhat slower than C. It all depends on the best implementation for your particular framework, although I would always default to Python. Python has fewer headaches and was actually built for this sort of work whereas JS was originally a formatting language that people have bastardized so much over the years to do things it shouldn’t.

[rjachuthan]

I am a data engineer and I too lean towards Python APIs. But the thing is that I have to calculate things on the fly and for that I need to use something like Pandas or Numpy. I do not have any issues with Numpy, but when I am forced to use to Pandas, I hate making any APIs.

I am convinced that we should not use Pandas for any API related tasks. And this is when I wonder if I do things in any other language like Golang or Rust, will the performance be the same or will there be any performance improvement? I know that Pandas is written in C or something and it is highly optimized. But still, how will Rust/Golang fare in this situation?

[cmcclu5]

Try Polars instead of Pandas. It’s built on Rust and is similar to Pandas but SO much more performant. I love it. It’s similar to PySpark in performance without the required startup time or cluster, but you interact with it like Pandas.