FastAPI Tutorial Day 1: Complete Beginner's Guide to Building REST APIs

Picture this: You’re at a coffee shop, and the barista takes your order, prepares it perfectly, and serves it with a smile — all in under 2 minutes. That’s FastAPI for you! While other web frameworks are still figuring out what you want, FastAPI has already delivered your perfectly crafted API with documentation so beautiful it makes you want to frame it.

If you’ve ever tried building APIs with other frameworks, you know the pain: mountains of boilerplate code, confusing documentation, and setup processes that feel like assembling IKEA furniture blindfolded. FastAPI throws all that out the window and says, “Hey, what if building APIs was actually… fun?”

Why Should You Care About FastAPI? 🤔

Speed That Makes Your Head Spin: FastAPI isn’t just fast — it’s “holy-cow-did-that-just-happen” fast. Built on Starlette and Pydantic, it’s one of the fastest Python frameworks available, rivalling Node.js and Go.

Automatic Documentation: Remember spending hours writing API docs? FastAPI generates interactive documentation automatically. It’s like having a personal assistant who’s actually good at their job.

Type Safety That Actually Works: Python’s type hints aren’t just for show anymore. FastAPI uses them to validate requests, serialize responses, and catch bugs before they catch you.

Modern Python Magic: Async/await support, dependency injection, and all the cool Python 3.6+ features you’ve been wanting to use but never had a good excuse for.

Setting Up Your FastAPI Kingdom 👑

Step 1: The Holy Trinity of Files

Every great API starts with proper organisation. Think of these files as the foundation of your digital empire:

requirements.txt — Your dependency wishlist:

fastapi
uvicorn
pydantictex

Why these three amigos?

FastAPI: The star of the show, your web framework
Uvicorn: The lightning-fast ASGI server that makes everything run
Pydantic: The data validation wizard that keeps your API bulletproof

Step 2: The Makefile — Your Personal Butler

Remember typing long commands and forgetting flags? Those days are over! A Makefile is like having a butler who remembers all your preferences:

start-env:
    python -m venv venv
    .\\venv\\Scripts\\activate
    pip install -r requirements.txt
run:
    uvicorn main:app --reload --port 1234

What’s happening here?

start-env: Creates a virtual environment (your isolated Python playground) and installs all dependencies
run: Starts your API server on port 1234 with hot-reload (changes update automatically!)

The syntax is beautifully simple: command name, colon, then the actual commands indented with tabs (not spaces — Makefiles are picky like that).

Step 3: Your First FastAPI App — The “Hello World” That Actually Does Something

Here’s where the magic happens. Create main.py:

from fastapi import FastAPI

def create_app():
    app = FastAPI(title="My FastAPI Application", version="1.0.0")
   
    @app.get("/health")
    def health_check():
        return {"status": "ok"}
      
    return app
app = create_app()

Breaking It Down Like a Boss:

FastAPI Import: We’re importing the main class that makes everything possible
create_app() Function: This factory pattern is like having a blueprint for your app — clean, testable, and professional
FastAPI Instance: Creating your app with a title and version (automatic documentation will thank you later)
@app.get(“/health”) Decorator: This is where FastAPI shows off — one line to create an endpoint!
health_check() Function: Returns a simple JSON response (FastAPI handles the JSON conversion automatically)

Taking Your API for a Test Drive 🏎️

Time to see your creation in action! Run these commands:

# Set up your environment
make start-env

# Start your API
make run

You’ll see something like:

INFO:     Uvicorn running on http://127.0.0.1:1234 (Press CTRL+C to quit)
INFO:     Started reloader process [12345] using statreload
INFO:     Started server process [12346]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Testing Your Masterpiece

Option 1 — Browser: Navigate to http://localhost:1234/health Option 2 - cURL: curl http://localhost:1234/health Option 3 - The Secret Weapon: Go to http://localhost:1234/docs for interactive documentation that'll blow your mind!

You should see:

{"status": "ok"}

The FastAPI Advantage — Why Developers Are Switching

Compared to Flask: No more wrestling with request parsing and response formatting.

Compared to Django: Get API power without the kitchen sink

Compared to Express.js: Stay in Python land with better performance

FastAPI feels like the framework Python developers always wished they had — intuitive, powerful, and surprisingly fun to work with.

What’s Next on This Journey? 🗺️

We’ve just scratched the surface! Coming up in this series:

Adding POST, PUT, and DELETE endpoints
Request validation that actually makes sense
Database integration without the headaches
Authentication that doesn’t make you cry
Deployment strategies that work in the real world

TLDR — Your FastAPI Cheat Sheet 📋

# Setup commands
make start-env    # Create virtual environment and install dependencies
make run         # Start the API server on port 1234

# Essential files
requirements.txt  # Your dependencies
Makefile         # Command shortcuts
main.py          # Your API code

# Quick test
curl http://localhost:1234/health

Key FastAPI Features to Remember:

Automatic JSON handling
Built-in data validation
Interactive documentation at /docs
Hot-reload during development
Type hints make everything better

Ready for Day 2? We’ll dive into different HTTP methods and start building something that looks like a real API. Trust me, it gets even better from here! 🎉

Pro tip: Keep that local server running and play around with the /docs endpoint – it's like having a playground for your API!