FastAPI vs. Django: Running Your First App

From Django's Structure to FastAPI's Simplicity

In Django, starting a project involves a formal ceremony: you run django-admin startproject to generate a directory structure, a manage.py script, and settings files. To get a single "Hello, World!" response, you typically need to create an app, define a view, and configure a URL pattern.

FastAPI streamlines this significantly. Let's see just how different the setup is.

As you saw, FastAPI requires much less boilerplate. Let's walk through the steps to create our own minimal application.

Step 1: Installation

First, you need two packages:

1. fastapi: The framework itself.
2. uvicorn: An ASGI (Asynchronous Server Gateway Interface) server to run your application.

Think of uvicorn as the FastAPI equivalent of the development server that runs when you execute python manage.py runserver in Django. While Django's server is built-in for development, FastAPI relies on a separate, production-ready ASGI server like Uvicorn.

Open your terminal and install them:

pip install fastapi "uvicorn[standard]"

(Note: We use "uvicorn[standard]" to include extra dependencies that provide better performance and WebSocket support, which will be useful later.)

Step 2: Creating Your First FastAPI App

Now, create a single file named main.py. This file will contain your entire application for now.

Add the following code to main.py:

# main.py
from fastapi import FastAPI




# 1. Create an instance of the FastAPI class
app = FastAPI()




# 2. Define a path operation decorator
@app.get("/")



# 3. Define the path operation function
async def root():



    # 4. Return the content
    return {"message": "Hello, World"}

Let's break this down, drawing parallels to Django:

1. app = FastAPI(): This creates the main application object. It's the central point of your API. All your routes, middleware, and configurations will be attached to this app instance. This is conceptually similar to your project's root urls.py in Django, where everything comes together.
2. @app.get("/"): This is a path operation decorator. It tells FastAPI that the function directly below it is responsible for handling requests that go to:
   • the path / (the root URL).
   • using a GET HTTP method.
     This decorator elegantly combines what Django separates into urlpatterns (the path) and the logic within a view that might check if request.method == 'GET'.
3. async def root():: This is your path operation function, the direct equivalent of a Django view function. We're using async def here, as we learned in the last lesson. Since we're just returning a dictionary and not performing any blocking I/O, both async def and def would work, but async is the natural default in FastAPI.
4. return {"message": "Hello, World"}: FastAPI automatically converts this Python dictionary into a JSON response with the appropriate Content-Type: application/json header. This is a major convenience compared to Django, where you'd typically use JsonResponse to achieve the same result.

Step 3: Running the Server

With your main.py file saved, go back to your terminal (make sure you're in the same directory) and run the following command:

uvicorn main:app --reload

Let's dissect this command:

• main: This refers to your main.py file (the Python module).
• app: This refers to the app = FastAPI() object you created inside main.py.
• --reload: This is a lifesaver for development. It tells Uvicorn to automatically restart the server whenever you save changes to your code, just like Django's runserver does.

The video below gives a great walkthrough of these steps.

Once you run the command, you should see output indicating the server is running, usually on http://127.0.0.1:8000. Open that URL in your browser, and you will see your JSON response: {"message":"Hello, World"}.

Step 4: Discovering the Automatic API Docs

Here is where FastAPI truly shines and offers a massive advantage out of the box. Now, navigate to http://127.0.0.1:8000/docs in your browser.

You will see an interactive API documentation page (Swagger UI). This was generated automatically by FastAPI based on your code.

Django/DRF Analogy: This is similar to the browsable API provided by Django REST Framework, but it's built into FastAPI itself and requires zero configuration. It adheres to the OpenAPI standard, which is the industry norm for documenting REST APIs.

This interactive documentation allows you to see all your endpoints, their parameters, and even test them directly from the browser.

Conclusion

Congratulations! You have successfully built and launched your first FastAPI application. While simple, this exercise highlights the core differences in developer experience compared to Django.

Key Takeaways:

• Workflow: The FastAPI workflow is install -> code -> run. It's more direct than Django's startproject -> startapp -> configure -> code -> run cycle for simple APIs.
• Server: FastAPI uses an ASGI server like Uvicorn to run. The command uvicorn main:app --reload is your equivalent of python manage.py runserver.
• Code Structure: A minimal app can exist in a single file. Path operations are defined concisely using decorators (@app.get) right above the functions that handle them.
• Automatic Docs: FastAPI provides free, interactive API documentation at the /docs endpoint, a powerful tool for development and collaboration.

In our next lesson, we will build upon this foundation. We'll explore how FastAPI leverages Python's type hints not just to improve documentation, but to provide powerful, automatic request validation—a role that serializers handle in DRF.