If you mention backend web development to our team, Django might be the first word you hear. This Python framework indeed allows us to set up significant projects while pairing it with a frontend application. In fact, Django is our go-to solution whenever we want to develop a backend. However, FastAPI, a more recent solution, seems to offer features that are worth exploring.
FastAPI? What is it?
FastAPI is an open-source web framework for creating REST APIs (Representational State Transfer) using the Python language. It was created 5 years ago and currently benefits from strong development by its creator, all in Open Source. The dual promise of this framework: performance and quick learning curve.
The advantages of FastAPI
The first thing to note is that it is indeed easy to learn! Setting it up is just as simple: in 5 lines of code, your application will be up and running! (Without any functionality, of course, that would be too good to be true). Here, we find all the ease of use of the Python language.
This framework aims to be very close to its programming language, as you will find typing features and data structures to create and use your models. Moreover, the creation of these models is managed through the Pydantic package, which allows defining objects using Python's typing. And you will quickly realize that this typing is particularly useful when FastAPI validates the consistency of your request data.
As mentioned at the beginning of the paragraph, no features were present when starting your project, but technically, that's not true. What developer doesn't appreciate documentation that is created as they code? Thanks to the integration of OpenAPI, that's exactly the case! Head over to the doc page of your application, and you'll find all the endpoints of your application listed, testable with pre-made requests—a real delight. And, of course, you can customize all this documentation.
Image taken from the FastAPI documentation
Thanks to these features and many others, FastAPI reveals its greatest strength: its flexibility. You can just as easily create a small project to, for example, keep the application running on a server to access your favorite Python functions, or create a more complex project with a database, security strategies, etc.
Facing the maturity of Django.
To begin the comparisons, let's talk about Django, a framework created in 2005, and notably DRF (Django REST Framework), which is a framework created in 2011, added to Django for creating a REST API.
The first thing to mention is the community, which is much larger for Django, and that's understandable given its years of existence. It will thus be much easier to find help with it. Nevertheless, the notoriety of FastAPI is growing rapidly, and the least we can say is that the framework is generating interest among developers.
Then, the flexibility of FastAPI is its greatest asset once again. In comparison to Django, which requires the user to use a database and format their project according to a standard, FastAPI allows the user to manage their code and project with much more flexibility, greatly facilitating skill development.
Let's discuss databases for our next point. There are only two types here: SQL databases and NoSQL databases. For the first type, the database is highly structured, organized into objects within tables that are linked together to match the schema you want. Typically, an ORM (object-relational mapping) will be used, and the fact that Django includes one by default gives it an advantage here. In FastAPI, you need to use an existing one and integrate it; however, this is done relatively naturally thanks to the creation of Pydantic models.
Python, the cornerstone of your scalable APIs
By placing Python at the heart of your API architecture, you combine simplicity, speed, and scalability to meet today's and tomorrow's challenges.
For the second type, these are often referred to as document databases. Widely used in machine learning and Big Data, this type of database has the advantage of not requiring hyper-structuring of data, unlike the first type. And the flexibility of FastAPI is a great asset here, as you don't necessarily have to create a precise structure for all your data. Django, on the other hand, does not support them natively.
The last point to highlight in favor of FastAPI is asynchronous programming, as it supports it natively!
Let's move on to the advantages of Django. Regarding security, for example, since it is older, it has ready-to-use libraries that allow you to integrate the security your application needs, and it can be implemented easily.
Finally, is Django less flexible? Is it less easy to handle? Yes indeed, but these disadvantages also have benefits. Once you get past the initial difficulties, your project will be easily scalable, and new features can be added more easily.
Compared to the simplicity of Flask.
Does FastAPI hold up against Flask? Created in 2010, Flask was designed to enable the creation of REST APIs in a single file. It is very easy to use, and any Python developer familiar with the concept of REST APIs can create one without much difficulty. Open Source and still maintained, Flask has a loyal community that appreciates its ease of use. For some, it is the gateway to REST APIs.
First, in terms of popularity, FastAPI already seems to be catching up with Flask despite its shorter lifespan. And for good reason, it feels like a supercharged Flask. Just as easy to handle when starting out, you quickly realize that many more features seem to be available for creating a larger-scale project.
So make no mistake, if you want a very lightweight REST API with few features, no security needs, or that won't evolve much, Flask remains very efficient and easy to deploy and develop. However, FastAPI seems much more interesting.
For what types of projects should you use FastAPI?
Does your project need an SQL database? It's entirely possible with FastAPI, and some projects will be well-suited for it. However, Django, with its integrated ORM, will allow for easier scalability and better application scalability if it needs to evolve.
A NoSQL database? Go ahead and give FastAPI a chance! Many projects related to Machine Learning and Big Data should find it beneficial: a NoSQL database offers much more flexibility for handling data that generally cannot (or very difficultly) adapt to an SQL structure.
Regarding security, Django will make implementation easier thanks to ready-made packages. However, FastAPI allows any seasoned Python developer, whether through the growing community or the ease of implementing its code, to establish your application's security.
No database is necessary, or security is optional? If you want a quick solution to implement, Flask remains a very good candidate here and can always connect to a database directly through Python if needed. Nevertheless, FastAPI, being quick to set up, will likely be a better solution thanks to its various features; you never know how far a project can evolve...
Our Verdict on FastAPI
In summary for FastAPI:
- Advantages:
- Flexible
- Fast
- Supports NoSQL databases and no need to use a database.
- Asynchronous programming
- Disadvantages:
- No integrated ORM for SQL databases
- Security is less quick to implement
- Scalability
- Still young
As Django developers, we must admit to being very impressed by the possibilities of FastAPI.
Looking forward to playing... I mean, working with it in the future.
