Flask vs MongoDB Comparison for Beginners

# app.py — a minimal Flask API
# The "what" you build before worrying about databases.

from flask import Flask, jsonify, request

app = Flask(__name__)

# In-memory store — replaced by MongoDB later
todos = []


@app.get("/health")
def health():
    return jsonify(status="ok")


@app.get("/todos")
def list_todos():
    return jsonify(todos)


@app.post("/todos")
def create_todo():
    data = request.get_json()
    if not data or "title" not in data:
        return jsonify(error="title is required"), 400
    todo = {"id": len(todos) + 1, "title": data["title"]}
    todos.append(todo)
    return jsonify(todo), 201


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


# Why this matters for the Flask-first path:
# - You have a real running app in minutes: `python app.py`.
# - You can test it in a browser or with curl.
# - The in-memory store proves the API works — now add a real database.
#
# What you learn here:
# - How Flask routes requests to functions
# - How to return JSON and set status codes
# - Why a health endpoint is a natural first test

# mongo_basics.py — how MongoDB actually works
# Runs against a real MongoDB instance using pymongo.

from pymongo import MongoClient
from datetime import datetime

client = MongoClient("mongodb://localhost:27017/")
db = client["mydb"]
todos = db["todos"]

# 1. Insert a document
todos.insert_one({
    "title": "Finish the Flask tutorial",
    "done": False,
    "created_at": datetime.utcnow(),
})

# 2. Insert many
todos.insert_many([
    {"title": "Write a MongoDB query", "done": False},
    {"title": "Ship the API", "done": False},
])

# 3. Read
pending = list(todos.find({"done": False}))
for doc in pending:
    print(doc["title"])

# 4. Update
todos.update_one(
    {"title": "Finish the Flask tutorial"},
    {"$set": {"done": True}}
)

# 5. Delete
todos.delete_one({"title": "Ship the API"})

# 6. Count
print("Pending:", todos.count_documents({"done": False}))

# What this teaches:
# - MongoDB stores documents (JSON-like), not rows.
# - Collections are like tables, but schema-flexible.
# - Queries look like Python dicts, not SQL strings.
# - CRUD operations map directly to API endpoints.
#
# Why this matters:
# - This is the exact shape of what Flask will call.
# - Understanding documents is the key idea in MongoDB.

# full_crud.py — Flask + MongoDB together
# The real combination every backend developer uses.

from flask import Flask, jsonify, request
from pymongo import MongoClient
from bson import ObjectId
from bson.errors import InvalidId

app = Flask(__name__)
client = MongoClient("mongodb://localhost:27017/")
db = client["mydb"]
todos = db["todos"]


def serialize(doc):
    """Convert MongoDB document to JSON-safe dict."""
    doc["_id"] = str(doc["_id"])
    return doc


@app.get("/health")
def health():
    return jsonify(status="ok")


@app.get("/todos")
def list_todos():
    docs = [serialize(d) for d in todos.find()]
    return jsonify(docs)


@app.post("/todos")
def create_todo():
    data = request.get_json()
    if not data or "title" not in data:
        return jsonify(error="title is required"), 400

    result = todos.insert_one({
        "title": data["title"],
        "done": data.get("done", False),
    })
    doc = todos.find_one({"_id": result.inserted_id})
    return jsonify(serialize(doc)), 201


@app.get("/todos/")
def get_todo(id):
    try:
        oid = ObjectId(id)
    except InvalidId:
        return jsonify(error="invalid id"), 400

    doc = todos.find_one({"_id": oid})
    if not doc:
        return jsonify(error="not found"), 404
    return jsonify(serialize(doc))


@app.put("/todos/")
def update_todo(id):
    try:
        oid = ObjectId(id)
    except InvalidId:
        return jsonify(error="invalid id"), 400

    data = request.get_json()
    todos.update_one({"_id": oid}, {"$set": data})
    doc = todos.find_one({"_id": oid})
    if not doc:
        return jsonify(error="not found"), 404
    return jsonify(serialize(doc))


@app.delete("/todos/")
def delete_todo(id):
    try:
        oid = ObjectId(id)
    except InvalidId:
        return jsonify(error="invalid id"), 400

    result = todos.delete_one({"_id": oid})
    if result.deleted_count == 0:
        return jsonify(error="not found"), 404
    return "", 204


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


# What this demonstrates:
# - The full CRUD cycle: Create, Read, Update, Delete.
# - ObjectId handling — the most common MongoDB gotcha.
# - Error handling for invalid ids and missing documents.
# - Why serialisation is needed (ObjectId isn't JSON-safe).
#
# Why interviewers look for this:
# - It proves you can connect Flask to a real database.
# - It shows you understand the Document model vs SQL.
# - It demonstrates API design thinking.