Flask vs Traditional Tools for Python Developers

# app.py — the same job in Flask
from flask import Flask, jsonify, request

app = Flask(__name__)
ORDERS = [
    {"id": 1, "total": 2400, "city": "Noida"},
    {"id": 2, "total": 1800, "city": "Delhi"},
]

@app.get("/orders")
def list_orders():
    city = request.args.get("city")
    rows = [o for o in ORDERS if not city or o["city"] == city]
    return jsonify(rows)

@app.get("/orders/<int:order_id>")
def get_order(order_id):
    for o in ORDERS:
        if o["id"] == order_id:
            return jsonify(o)
    return jsonify({"error": "not found"}), 404

if __name__ == "__main__":
    app.run(debug=True)

# ~20 lines. No ORM, no admin, no config.
# Add what you need, when you need it.

# script.py — same data, no web layer
import csv
import sys

def load(path="orders.csv"):
    with open(path) as f:
        return list(csv.DictReader(f))

def main():
    city = sys.argv[1] if len(sys.argv) > 1 else None
    rows = load()
    if city:
        rows = [r for r in rows if r["city"] == city]
    for r in rows:
        print(r["id"], r["total"], r["city"])

if __name__ == "__main__":
    main()

# Run: python script.py Noida

When the script is enough:
✓ Only you run it
✓ Output is a file or a terminal print
✓ No one else needs to call it over HTTP

When you need Flask instead:
✗ Someone else must call it
✗ It has to run continuously
✗ It must return JSON to a frontend

# Flask — GET /orders returns a list
from flask import Flask, jsonify

app = Flask(__name__)

@app.get("/orders")
def orders():
    return jsonify([{"id": 1, "total": 2400}])

# Lines of code: 6
# Validation: manual
# Docs: manual (use flasgger or similar)
# Async: no (without extra work)

# Django (with DRF) — same endpoint
# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path("orders/", views.OrderList.as_view()),
]

# views.py
from rest_framework import generics
from .models import Order
from .serializers import OrderSerializer

class OrderList(generics.ListAPIView):
    queryset = Order.objects.all()
    serializer_class = OrderSerializer

# Lines of code: ~15 across 3 files
# Validation: serializers
# Admin: free via Django admin
# Auth: built-in
# Async: partial in recent versions

# FastAPI — same endpoint with types + docs
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Order(BaseModel):
    id: int
    total: float

@app.get("/orders", response_model=list[Order])
def list_orders():
    return [{"id": 1, "total": 2400}]

# Lines of code: 10
# Validation: automatic via Pydantic
# Docs: /docs for free
# Async: yes, first-class
# Type hints required: yes

# streamlit_app.py — 12 lines to a working data app
import streamlit as st
import pandas as pd

st.title("Sales Dashboard")

df = pd.read_csv("data/sales.csv")
month = st.selectbox("Month", sorted(df["month"].unique()))
filtered = df[df["month"] == month]

st.metric("Total revenue", f"₹{filtered['revenue'].sum():,}")
st.bar_chart(filtered.groupby("region")["revenue"].sum())

# Run: streamlit run streamlit_app.py
# Time to working demo: 15 minutes
# URL control: none
# Auth: not built in
# API endpoints: no

# Flask equivalent — more control, more code
from flask import Flask, render_template, request
import pandas as pd

app = Flask(__name__)

@app.route("/")
def index():
    df = pd.read_csv("data/sales.csv")
    month = request.args.get("month", df["month"].iloc[0])
    filtered = df[df["month"] == month]

    return render_template(
        "index.html",
        months=sorted(df["month"].unique()),
        month=month,
        total=int(filtered["revenue"].sum()),
        rows=filtered.groupby("region")["revenue"].sum().to_dict(),
    )

# + templates/index.html
# Time to working demo: 2-3 hours
# URL control: yes
# Auth: yours to build
# API endpoints: add as needed
# Control over UI: yes

Rule: Streamlit first if the audience is you and a few
colleagues. Flask when it becomes a product.

Python tool decision matrix:

Question                              → Tool
------------------------------------------------------
Do you need a web UI at all?          → No: script/cron
Is it a data demo for stakeholders?   → Streamlit
Do you need typed, async APIs?        → FastAPI
Do you need admin + auth + ORM?       → Django
Do you need a small custom web app?   → Flask
Multiple of the above?                → Split into services

Scoring template (1-5):

Factor                      Flask  Django  FastAPI  Streamlit
Speed to first working app    [ ]    [ ]     [ ]      [ ]
Flexibility                   [ ]    [ ]     [ ]      [ ]
Typed validation              [ ]    [ ]     [ ]      [ ]
Auth / admin built-in         [ ]    [ ]     [ ]      [ ]
Async support                 [ ]    [ ]     [ ]      [ ]
Total:                        ___    ___     ___      ___

Feature checklist — answer before choosing:

☐ Does someone other than you use this?
☐ Does it need to run 24/7?
☐ Does it need user accounts?
☐ Does it need to call another service?
☐ Does it need to be called by another service?
☐ Does it store state between requests?
☐ Does it need to run on a schedule?
☐ Does it need to be auditable?

If you answered "no" to all of these:
  → Plain script + cron is enough.

If only "someone other than you" and "24/7":
  → Streamlit for demo, Flask for product.

If "users" and "state":
  → Django.

If "called by another service" and "no UI":
  → FastAPI (or Flask if you want minimal).

Migrating Streamlit → Flask (when you outgrow it):

1. Identify the core page (usually one)
2. Copy the data loading code — unchanged
3. Move charts to Jinja + a JS chart lib (Chart.js)
4. Replace st.selectbox with a <select> in a GET form
5. Replace st.metric with a Jinja variable
6. Add routes: /, /download, /api/summary
7. Deploy with gunicorn

Migrating Flask → Django (when you need auth/admin):

1. Create a Django project, copy models from your schemas
2. Migrate data with a one-off script
3. Move Flask routes into views (Django FBVs look similar)
4. Let Django admin handle the CRUD you were writing manually
5. Move templates — syntax is close (Jinja ≈ Django Templates)
6. Replace Flask login with Django's auth middleware

Migrating Flask → FastAPI (when you need typed APIs):

1. pip install fastapi uvicorn
2. Define Pydantic models for each request/response
3. Convert routes to @app.get / @app.post with type hints
4. Replace manual validation with Pydantic
5. Free /docs — delete your handmade swagger