Unveiling the Python Web Framework Trilemma: Django, Flask and the Maturing FastAPI

In the ever-evolving realm of Python web development, the choice of a framework lays the foundation for your project's success. Today, we embark on a journey through three prominent contenders: Django, Flask and the maturing FastAPI. Each possesses a unique set of strengths and weaknesses, catering to developers' diverse needs and preferences.

Django: A Symphony of Full-Stack Mastery

Full-Stack Excellence:

Django comes as a truly complete framework and stands as a testament to full-stack development, offering a comprehensive solution with built-in features such as ORM with migration management capabilities, full-scale authentication & and authorization, robust customizable admin interface, signals, very capable CLI and many more. Its "batteries-included" philosophy accelerates development by providing everything needed out of the box, fostering a swift and efficient workflow.

Solid Community Backbone:

Beyond its technical prowess, Django's strength lies in its vibrant community. Joining this community opens the door to a vast pool of knowledge and third-party packages, creating a collaborative and supportive developer environment. It also has a very stable timeline of release which makes it easier for anyone to plan long-term without having to worry about updating applications on irregular intervals.

However, with great power comes certain considerations.

Monolithic Footprint:

For smaller projects, Django's extensive features may introduce unnecessary complexity. To overcome this, modularize your project, breaking it down into smaller, reusable apps while retaining Django's benefits.

Learning Curve Summit:

While the learning curve can be steep, especially for newcomers, comprehensive documentation and hands-on experience can significantly ease the journey. Workshops and training sessions dedicated to Django can provide valuable insights.

Mitigating Djangos Limitations with DRF: Elevating API Development

Djangos monolithic nature for smaller projects:

Enter Django Rest Framework (DRF):

Django Rest Framework (DRF) steps in as a sophisticated solution to address certain limitations in Django. It seamlessly integrates with Django, extending its capabilities to robust API development.

Solving the Monolithic Footprint:

For smaller projects, where Django's comprehensive nature might feel like overkill, the inclusion of DRF provides a refined approach. You can modularize your project, leveraging DRF's powerful API features while maintaining the flexibility to scale as your project grows.

API Development Simplicity with DRF:

DRF simplifies API development, providing tools for serialization, authentication and view sets out-of-the-box. The combination of Django and DRF makes it easier to create APIs, ensuring your project is well-equipped to meet modern development requirements and at the same time making maintenance a breeze.

Learning Curve Harmony:

While Django's learning curve might be a concern, DRF's seamless integration means developers can build on their existing knowledge of Django concepts. This synergy between the two frameworks promotes a smoother learning curve for API-specific development. I don't view DRF as a separate framework at all, rather I see it as an excellent extension to Django itself.

Flask: Lightweight Freedom in Action

Lightweight Agility:

Flask's charm lies in its lightweight design, offering the flexibility to cherry-pick components. It's an excellent choice for small to medium-sized applications where simplicity and flexibility are paramount.

Freedom to Extend:

Flask's minimalistic core provides the freedom to extend functionality seamlessly. Third-party extensions allow developers to tailor their applications precisely to their needs.

Yet, challenges may arise.

Feature Scarcity Dilemma:

The minimalism of Flask, while a strength, may lead to the absence of certain built-in functionalities present in more comprehensive frameworks. Mitigate this by embracing Flask's extensibility, judiciously incorporating necessary features.

Not for the Grandiose:

Scaling challenges may surface for larger and more intricate projects. Consider adopting a microservices architecture, breaking down large projects into smaller, manageable services, each built with Flask.

FastAPI: Newby takes over the game by storm

Asynchronous Prowess:

FastAPI shines with its asynchronous support, ensuring efficient handling of concurrent requests for optimal performance. The ASGI standard that FastAPI implements with such precision is even making heavyweights like Django reshape their journey towards ASGI from the legacy WSGI.

Automatic Documentation Magic:

Automatic API documentation generation streamlines the development process, fostering collaboration and ease of understanding. Although it learned this feature from its predecessor Django REST Framework (which also provides visual documentation out-of-the-box), the implementation of FastAPI is more pleasing to the eyes and provides a better "Developer Experience" (DX).

Yet, perceptions need adjustment.

The Myth of Novelty:

FastAPI, once considered novel, has rapidly matured and gained substantial community support. Regularly checking for new releases and community contributions dispels any concerns related to its novelty factor.

Async Learning Curve:

Asynchronous programming, a key feature of FastAPI, might pose a learning curve. Invest in training and mentorship within the team, encouraging hands-on practice to accelerate the learning curve.

Conclusion: My takes

Personally, my journey started with Flask, then on to Django and finally FastAPI, which I am using for all my projects at my workplace. Having comprehensive experience in each of these 3 most popular Python web frameworks allows me to provide better judgment on crowning the king of all. But, to me, there's NO KING in this game! Rather, I have two princes in a very stable competition.

Although I started my journey with Flask and consider it a very beginner-friendly and easygoing "library" for building backend services, I am not a fan of Flask. The one advantage of the go-to choice of simplicity the flask has already been taken over by FastAPI from all perspectives. Whether it is the simplicity or the community, Flask has been left miles behind by FastAPI. The only advantage I can see Flask still has over FastAPI is the number of apps using Flask but being very similar to Flask in syntax but more modern, I can foresee that most Flask apps will embrace FastAPI soon. On top of that, it is very easy for Flask developers to learn FastAPI and migrate an application from Flask to FastAPI, which just makes the transition more probable. So, though unwilling, I must respectfully admit Flask is an aging player losing its edge in the game, but cannot keep up with the young star, FastAPI.

The two princes that I mentioned earlier are Django and FastAPI, both having a similar amount of popularity among developers. While Django is a battle-tested framework passing the test of time, FastAPI is taking the game by storm and it has been phenomenal. The FastAPI community is really smart and learns from a wide range of frameworks. Both Python and other languages took the best of all. Moreover, FastAPI is easy to learn and produce, yet highly performant. Although late in the game, it deserves to be one of the princes of Python web development games. I cannot criticize any aspect of this "library". The only advantage I see Django having over FastAPI is the built-in ORM along with many other batteries like the admin panel, customizable authentication and authorization system, signals etc. The Django ORM is truly a big advantage of Django over any other framework. In my work, this is where I faced the most difficulties when using FastAPI, setting up the migration management system along with SQLalchemy as the ORM is truly cumbersome. The other batteries I mentioned are also a huge advantage of Django over FastAPI.

The reason why I haven't crowned Django as the king is not because of any of its shortcomings, but rather the smartness, visions and goals of the FastAPI community. Although FastAPI does not have the batteries Django comes with, its documentation is great. Both the feature and the official FastAPI documentation that we should and I suggest must, use to learn the library. Moreover, implementing the ASGI standard is also a big plus which Django is trying to replicate. From this, we can understand the impact the young star FastAPI has made in the game as a latecomer. Moreover, Sebastián Ramírez Monta?o, the creator of? FastAPI, is planning to make Django ORM usable with FastAPI. I believe this is the smartest decision for the future of FastAPI and once this is done, FastAPI can quickly bring home all the good things of Django (the admin panel, the built-in authentication and authorization system, signals and others) as they are closely connected with the Django ORM. If in the future I truly see this happening, I will put the king's crown on FastAPI as it will no longer be inferior to Django in any aspect and will take over the game from Django after more than an era of brilliance. I also see Django as more stable and mature as of now and it's more reliable in big projects because of strict timelines of release. But FastAPI, after all, is a newcomer and needs a little time to mature completely and I don't think that day is far.

In the end, the trilemma of Python web frameworks does not have any one-size-fits-all solution. The choice between Django, Flask and FastAPI hinges on your project's unique requirements, your team's expertise and your development goals. The opinions I shared are just the opinion of one person, it does not change the fact that all three of them are great frameworks and have made great contributions to today's world. So no one should undermine any of them. Embrace the strengths, address the challenges and consider the strategic approaches outlined to overcome potential disadvantages. Whichever path you choose, remember that the journey is as important as the destination.? Happy coding!?

Written by Md Abdur Rakib (Head of Backend and Infrastructure).