What's next: choosing your path

What you'll learn

• See the five main directions Python developers take after the fundamentals: web, data, automation, DevOps, and AI
• Know what each path builds on from this course and what it adds
• Pick one deliberately, using your own goal from lesson 1 rather than what is loudest online
• Take the first concrete step on that path this week

Concept

You now know Python the language, and you know how production code is built. That is the trunk. What grows from it depends on what you want to make, and the good news is that every branch reuses almost everything you have learned. The differences between paths are mostly which libraries you learn next and which problems you spend your days on. Choosing is not a commitment for life; it is a decision about the next six months.

Web back ends build the services behind sites and apps. FastAPI turns type-hinted functions into HTTP endpoints and uses asyncio, dataclass-like models, and dependency injection you already understand; Django is the larger, batteries-included framework with an ORM, admin, and auth. You will add SQL depth, HTTP semantics, authentication, and deployment at scale. Data work means getting answers from data: pandas for tables, SQL for querying, notebooks for exploration, and plotting for communication; it adds statistics and a habit of checking your assumptions against the numbers. Both paths hire steadily.

Automation and scripting is the path where Python pays off fastest in daily life: tools built on subprocess, pathlib, and httpx that rename, file, fetch, report, and notify, gluing together the APIs of services you already use. It adds little theory and a great deal of practical knowledge of other systems. DevOps and platform work takes the Docker, CI, and configuration lessons further into cloud providers, infrastructure as code, and running systems reliably; it suits people who like making things work at scale more than making features. AI applications is the newest path: calling language models over HTTP, structuring their output with typed models, retrieving documents to ground answers, and evaluating results with tests, all skills this course covered under other names.

Choose by returning to the sentence you wrote in lesson 1. If it was a product, web is likely your path. If it was a question about numbers, data. If it was a chore, automation. If you found the Expert level's deployment lessons the most satisfying, DevOps. If you kept wanting to wire a model into something, AI applications. Then pick the first project from the table, size it to two weekends, and start. Reading about paths is procrastination in a good disguise; a finished small project on one path teaches more than a survey of all five.

Code

The same library, three ways it grows on three paths. Each snippet is the seed of a first project: an HTTP endpoint shape, a data analysis, and an automation, all standing on code you have already written.

# seeds.py
from collections import defaultdict
from dataclasses import dataclass, asdict
from datetime import date
import json

@dataclass(frozen=True)
class Expense:
    day: date
    category: str
    amount: float

expenses = [Expense(date(2026, 9, 1), "rent", 950), Expense(date(2026, 9, 2), "food", 12.5),
            Expense(date(2026, 9, 9), "food", 31), Expense(date(2026, 8, 30), "food", 9)]

# web path: what an endpoint returns (FastAPI would call a function like this and serialize the result)
def get_report(month: str) -> dict:
    by_cat = defaultdict(float)
    for e in expenses:
        if e.day.strftime("%Y-%m") == month:
            by_cat[e.category] += e.amount
    return {"month": month, "by_category": dict(by_cat), "count": sum(1 for e in expenses if e.day.strftime("%Y-%m") == month)}

print("web   ->", json.dumps(get_report("2026-09")))

# data path: a question answered from the records (pandas would do this in one line on a million rows)
food = [e.amount for e in expenses if e.category == "food"]
print(f"data  -> food: n={len(food)} mean={sum(food)/len(food):.2f} max={max(food)}")

# automation path: a rule that would run on a schedule and notify
budget = {"food": 40}
over = {c: round(sum(e.amount for e in expenses if e.category == c and e.day.month == 9) - limit, 2)
        for c, limit in budget.items()}
print("auto  ->", {c: f"over by {v}" for c, v in over.items() if v > 0} or "within budget")

web   -> {"month": "2026-09", "by_category": {"rent": 950.0, "food": 43.5}, "count": 3}
data  -> food: n=3 mean=17.50 max=31
auto  -> {'food': 'over by 3.5'}

A decision worksheet you can run: answer four questions and it suggests a path and a first project. It is a nudge, not an oracle; the point is to write the answers down.

# choose.py
PATHS = {
    "web": ("Web back ends (FastAPI/Django)", "turn the expense library into a REST API with login"),
    "data": ("Data and analysis (pandas, SQL)", "analyze a year of your own data and chart it"),
    "automation": ("Automation and scripting", "build the tool that removes one weekly chore"),
    "devops": ("DevOps and platform", "deploy the capstone to a cloud with monitoring"),
    "ai": ("AI applications", "a Q&A tool over your own documents with tests"),
}

answers = {
    "goal_kind": "chore",            # product | numbers | chore | systems | model
    "favourite_level": "beginner",   # fundamentals | beginner | advanced | expert
    "favourite_lesson": "automation",  # any lesson slug word
    "hours_per_week": 6,
}

kind_to_path = {"product": "web", "numbers": "data", "chore": "automation", "systems": "devops", "model": "ai"}
path = kind_to_path[answers["goal_kind"]]
if answers["favourite_level"] == "expert" and path in ("web", "automation"):
    path = "devops"
name, project = PATHS[path]
weekends = max(2, round(20 / max(answers["hours_per_week"], 1)))
print(f"path: {name}")
print(f"first project: {project}")
print(f"size: about {weekends} weekends at {answers['hours_per_week']} h/week; start this week")

path: Automation and scripting
first project: build the tool that removes one weekly chore
size: about 3 weekends at 6 h/week; start this week

Try it yourself

Fill in choose.py with your real answers and run it. Whatever it suggests, write one paragraph in a file called next.md: the path, the first project, what done looks like, and the date you will have it running. Then install the first library on that path, fastapi, pandas, or whichever applies, in a fresh project with the production shell from the capstone, and make it print hello. That is the first step, and it should happen before the next lesson.

Common mistakes

• Choosing by job-market noise. Every path on this list hires; the one you will finish projects on is the one aligned with your goal.
• Surveying all five. Reading about paths feels like progress and is not; one small finished project on one path is.
• Waiting to be ready. You are ready; the capstone proved it. Start the first project this week.

What's next

• Five paths grow from this course: web, data, automation, DevOps, and AI applications; each adds libraries, not a new language.
• Choose by your lesson-1 goal, pick the first project from the table, size it to a few weekends, and start now.
• Every path reuses the production shell you built in the capstone.

You have a direction. Next, how to keep getting better once the course is behind you: practice that compounds.