Course Progress100%
🍎 Python What's Next 🎉 Final Lesson — 100 / 100
⏳ 12 min read

What Comes After Python

Your roadmap forward — AI & ML, web development, data science, automation, and the mindset that will take you from here to anywhere.

🎉☀🌟

You finished all 100 lessons.

You started with print("Hello") and ended calling AI APIs, building web apps, packaging libraries, and writing tested, production-quality code.
That journey is not a small thing.

100 Topics mastered
✓ Tests written
✓ APIs called
✓ Code shipped

Everything You Learned — A Visual Recap

One hundred topics, organised into six chapters. Each box is a skill you now own:

🌾 Chapter 1 — Foundations (Topics 1–25)
Variables & Types Strings Lists & Tuples Dicts & Sets if / elif / else for & while loops Functions Scope & Closures Error Handling File I/O Modules & Packages List Comprehensions Lambda & map/filter
👀 Chapter 2 — Object-Oriented Python (Topics 26–45)
Classes & Objects __init__ & self Inheritance Polymorphism Dunder Methods Decorators @property Dataclasses Abstract Classes Type Hints
Chapter 3 — Advanced Python (Topics 46–70)
Generators & Iterators Context Managers async / await Threading Multiprocessing Regular Expressions JSON & CSV functools Environments & pip
📊 Chapter 4 — Data Science Stack (Topics 71–87)
NumPy Arrays Indexing & Slicing Broadcasting pandas DataFrames groupby & merge Missing Data matplotlib requests & APIs Web Scraping
🌐 Chapter 5 — Web & Databases (Topics 88–92)
Flask Routes REST APIs jsonify SQLite CRUD SQL Placeholders Row Factory
⚙️ Chapter 6 — Professional Tools (Topics 93–100)
unittest pytest & fixtures logging levels argparse CLI Performance & profiling pyproject.toml PyPI publishing scikit-learn AI APIs

What You Can Build Today

Before picking what to learn next, recognise what you can already create — right now, with the knowledge you have:

🌐
Web APIs & Backends
Flask REST APIs, SQLite databases, user auth, JSON responses, deployable apps. A real backend that a mobile or frontend app can talk to.
🤖
AI-Powered Tools
Call OpenAI / Anthropic APIs, classify text, summarise documents, build chatbots, automate writing workflows — all with your Python skills.
📊
Data Pipelines
Fetch, clean, analyse and visualise data with pandas + matplotlib. Automate daily reports. Scrape sites and store results in SQLite.
⚙️
Automation Scripts
File processors, scheduled jobs, email senders, PDF generators, price trackers — tools that run while you sleep and save you hours every week.
🧬
ML Models
scikit-learn classifiers, regressors, clustering. Train on real data, evaluate honestly, serve predictions through a Flask endpoint.
📚
Publishable Packages
Properly structured packages with pyproject.toml, pytest test suites, and a README — ready to publish on PyPI for the world to install.

Choose Your Path — Four Roads Forward

There is no single right next step. Pick based on what you want to build, not what seems most impressive. Here is what each path involves, concretely:

🤖
Path A — AI & Machine Learning
Goal: build ML models, work with LLMs, do data science, enter AI research
Step 1
scikit-learn mastery — every classical algorithm: Ridge/Lasso regression, Decision Trees, Random Forests, SVMs, k-means clustering, cross-validation, feature engineering. Do the Kaggle Titanic and House Prices competitions.
Step 2
PyTorch — build neural networks from scratch: forward pass, backpropagation, optimisers. CNNs for images. The fast.ai Practical Deep Learning course teaches this better than anything else (free).
Step 3
Hugging Face Transformers — load BERT, GPT-2, Llama in three lines. Fine-tune on your own data. Sentiment analysis, NER, summarisation — state-of-the-art NLP without building from scratch.
Step 4
LangChain / LlamaIndex — build RAG (retrieval-augmented generation) pipelines. Chat with your own documents. Multi-step AI agents. The cutting edge of applied LLM development.
📚 Start with: fast.ai Practical Deep Learning (free at course.fast.ai) — then Andrej Karpathy's Neural Networks: Zero to Hero on YouTube.
🌐
Path B — Full-Stack Web Development
Goal: build websites and SaaS products, work as a backend or full-stack developer
Step 1
Django — Flask's bigger, batteries-included sibling. Built-in ORM, admin panel, auth, migrations. The official Django tutorial takes one focused weekend and gets you from zero to a functional web app.
Step 2
FastAPI — modern, async, auto-generates OpenAPI docs. The best choice for building APIs that serve ML models, mobile apps, or any JavaScript frontend. Faster than Flask, cleaner than Django REST.
Step 3
PostgreSQL + SQLAlchemy — upgrade from SQLite. Proper relations, migrations with Alembic, connection pooling. This is the stack behind most production Python web apps.
Step 4
Docker + Cloud Deploy — containerise your app so it runs identically everywhere. Deploy on Railway, Render, or Fly.io. Your API is live on the internet with a real URL.
📚 Start with: the official Django tutorial at docs.djangoproject.com — then TestDriven.io for FastAPI + Docker in depth.
📊
Path C — Data Science & Analytics
Goal: answer business questions with data, work as an analyst or data scientist
Step 1
Statistics — probability distributions, hypothesis testing, p-values, confidence intervals, correlation vs causation. This is the thinking layer under every data analysis. Without it, you misread results.
Step 2
seaborn + plotly — beautiful statistical visualisations (violin plots, heatmaps, regression lines) and interactive charts for dashboards and stakeholder presentations.
Step 3
SQL mastery — complex JOINs, window functions (ROW_NUMBER, LAG, LEAD), CTEs, subqueries. Most data analyst roles test SQL at least as hard as Python. Both matter equally.
Step 4
Streamlit — turn a Python script into a live interactive web app with sliders, charts, and file uploads in minutes. No JavaScript. Your analysis becomes a product anyone can use in a browser.
📚 Start with: Kaggle Learn free micro-courses (pandas, SQL, data viz) — then pick any Kaggle Playground competition to apply the skills on real data.
⚙️
Path D — Automation, DevOps & Tools
Goal: automate everything, infrastructure engineering, build internal tools, make yourself 10× faster
Step 1
Bash + Linux — shell scripting, cron jobs, file system operations, pipes, grep, sed, awk. The glue layer under every automated system. Python talks to Bash and Bash runs the world's servers.
Step 2
Docker — containerise your Python apps so they run identically on every machine. docker build, docker run, docker compose. No more dependency hell. The single most employable skill in this list.
Step 3
GitHub Actions — CI/CD: automatically run your pytest suite on every git push, lint with ruff, build Docker images, deploy to production. Software that tests and ships itself.
Step 4
Celery + Redis — background task queues. Run long jobs (sending emails, processing images, calling AI APIs) asynchronously without blocking your web server or timing out requests.
📚 Start with: The Linux Command Line by William Shotts (free online) — then Docker's official getting-started guide at docs.docker.com.

8 Projects to Build Right Now

Pick one project that genuinely interests you and start it today. Building is what separates people who know Python from people who can do things with Python:

Project Skills it uses from this course Level
🌞 Weather Dashboard requests, pandas, matplotlib, argparse Beginner
📋 Personal Task API Flask, SQLite, REST, pytest, logging Beginner
📦 Price Tracker BeautifulSoup, SQLite, email alerts, cron Intermediate
🤖 AI Document Summariser Anthropic / OpenAI API, Flask, async, logging Intermediate
📈 Stock Screener CLI argparse, requests, pandas, matplotlib, logging Intermediate
🎬 Movie Recommendation Engine scikit-learn, pandas, Flask API, pytest Advanced
💬 RAG Chatbot on your docs LangChain, LLM API, async, packaging, Flask Advanced
⚙️ GitHub Actions CI Pipeline pytest, packaging, logging, argparse, Docker Advanced

One Last Piece of Code

This program uses nearly every concept from this course together — clean, typed, tested, and purposeful. This is the kind of code you can now write:

python — hn_top.py — a complete, professional-grade CLI tool
"""
Fetch and display top Hacker News stories in the terminal.
Uses: argparse, dataclasses, type hints, requests, logging,
      error handling, f-strings, list comprehensions.
Run: python hn_top.py --limit 5 --min-score 300
"""
import argparse, logging, sys
import requests
from dataclasses import dataclass
from typing      import Optional

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
log = logging.getLogger(__name__)
BASE = "https://hacker-news.firebaseio.com/v0"

@dataclass
class Story:
    title  : str
    score  : int
    by     : str
    url    : Optional[str] = None

    def display(self, rank: int) -> None:
        print(f"\n  {rank:>2}. {self.title}")
        print(f"      ★ {self.score} pts  👤 {self.by}")
        if self.url:
            print(f"      🔗 {self.url}")

def fetch_story(sid: int) -> Optional[Story]:
    try:
        d = requests.get(f"{BASE}/item/{sid}.json", timeout=5).json()
        return Story(title=d["title"], score=d.get("score",0),
                     by=d.get("by","?"), url=d.get("url"))
    except Exception:
        return None

def main() -> None:
    p = argparse.ArgumentParser(description="Top Hacker News stories")
    p.add_argument("--limit",     type=int, default=10, help="Stories to fetch")
    p.add_argument("--min-score", type=int, default=0,  help="Min score filter")
    args = p.parse_args()

    log.info(f"Fetching top {args.limit} stories...")
    try:
        ids = requests.get(f"{BASE}/topstories.json", timeout=5).json()
    except requests.exceptions.RequestException as e:
        log.error(f"Network error: {e}")
        sys.exit(1)

    # list comprehension + filter — topics 10 & 18
    stories = [s for sid in ids[:args.limit * 2]
               if (s := fetch_story(sid)) and s.score >= args.min_score][:args.limit]

    print(f"\n📊 Top {len(stories)} Hacker News stories"
          f"{f' (score ≥ {args.min_score})' if args.min_score else ''}")
    print("─" * 55)
    for rank, story in enumerate(stories, 1):
        story.display(rank)

if __name__ == "__main__":
    main()
terminal — run it
python hn_top.py --limit 3 --min-score 400

INFO Fetching top 3 stories...

📊 Top 3 Hacker News stories (score ≥ 400)
───────────────────────────────────────────────────────

   1. Show HN: I rewrote curl in 300 lines of Python
      ★ 1,243 pts  👤 systems_py
      🔗 https://github.com/systems_py/tinycurl

   2. The day I stopped writing documentation and started writing tests
      ★ 876 pts  👤 engblog
      🔗 https://engblog.medium.com/tests-are-docs

   3. Ask HN: What Python project made you actually understand classes?
      ★ 541 pts  👤 curious_dev

The Programmer’s Mindset — What Stays True Forever

Languages come and go. Frameworks rise and are replaced. These habits stay valuable no matter what you build or which tools you use:

🔍
Read the error — really read it
90% of bugs are solved by reading the last three lines of the traceback carefully. The error message tells you exactly what broke and on which line. The instinct to Google immediately before reading is something to fight.
📂
Check the official docs first
docs.python.org, PyTorch docs, Hugging Face docs. Written by the people who built the tool. Almost always the clearest and most accurate explanation. A habit of reading docs makes you consistently faster than peers who skip straight to Stack Overflow.
🐠
Rubber-duck your bugs
Explain your code out loud — to a rubber duck, a friend, or an AI. The act of articulating what each line does almost always reveals where the assumption broke. It sounds silly. It works every time.
🚚
Ship imperfect, then improve
A working v1 that exists beats a perfect v3 that’s still being planned. Real users on real code reveal real problems. No amount of thinking in isolation does this. Ship something, observe how it breaks in practice, then fix what actually matters.
🎗
Teach what you learn
Write a blog post. Answer a question on a forum. Explain a concept to a friend. Teaching forces you to find the gaps in your own understanding — it is the fastest path to genuine mastery, not just surface familiarity.
📈
Every project goes on GitHub
Commit early and often. Your GitHub history is your portfolio — it is what employers and collaborators actually look at. A consistent green commit graph says more than any CV line. Start putting code there from day one of every project.
🌟

You started not knowing Python.
Now you can build things that matter.

You can read codebases, write tests, call AI APIs, analyse data, build web APIs, and publish packages. That’s a real, complete foundation — not a tutorial. Go build something. Start today.

🧠 Quiz — Q1

You want to build a chatbot that answers questions about your company's internal documents. Which learning path fits best?

🧠 Quiz — Q2

When you get a Python traceback, what is the single most effective first step?

🧠 Quiz — Q3

You have learned classes, generators, decorators, async, and requests. What PyTorch concepts do these directly map to?

🧠 Quiz — Q4

Why does "ship imperfect, then iterate" lead to better software than planning until everything is perfect?