You can build real programs now. Here's the ladder up.

Plain English first: you have finished the part everyone finds hardest. You started at zero and you can now write, read, and build real Python — not just snippets, but a complete end-to-end program. That foundation is identical no matter where you go next. This last page is a map: it shows the full arc you climbed and then points each rung above you straight back at the skills you just earned, so you know exactly why you're ready.

The whole arc you just climbed

Part 1 — The basics took you from "what even is a program" to writing small scripts:

• Variables, types, and operators — storing values and computing with them.
• Control flow — if/elif/else decisions, for/while loops, and functions to name reusable chunks of work.
• The everyday containers — lists, dictionaries, sets, and strings.
• Errors and debugging — reading a traceback last-line-first, and a repeatable problem-solving loop.

Part 2 — From scripts to programs gave you the skills real software is actually made of, the ones the next guides assume:

• Tuples and comprehensions — the compact, Pythonic idioms real code is written in ([x for x in items], unpacking, enumerate/zip).
• Modules and imports — building on the standard library and third-party packages from PyPI with pip. You no longer write everything yourself.
• Files and exceptions — reading and writing files with with open(...), and handling failure deliberately with try/except/raise.
• Classes and objects — bundling data with behavior; enough OOP to read the SDK clients and request/response objects in every modern library.
• JSON and APIs — parsing and navigating the structured data that programs exchange, and the concept of an HTTP API that returns JSON.
• Running Python locally — installing Python, the terminal, virtual environments, pip install, and running a .py file: the move from browser to building.
• Version control with Git and GitHub — saving labelled snapshots (commits) of your work, a .gitignore to keep secrets and the venv out, and pushing a repo to GitHub so your projects are backed up and shareable.
• The capstone — proof you can combine all of it into one working CLI tool.

That last part matters: you didn't just learn syntax, you learned the shape of real programs. That's what makes you ready for what's next.

First, lock it in

The single best thing you can do right now is build something small of your own on your own machine — take the capstone tool and bend it to a real need: a script that summarizes a CSV/JSON file you care about, a tiny CLI to-do list that saves to a file, a program that reads some data and prints a report. You will hit errors; that is the point. Re-read Errors, debugging, and how to think whenever you get stuck. Fixing your own bugs is what turns "I followed a tutorial" into "I can program."

Then climb: specialize → interview → prove

Map: each guide → the Programming Basics skills it builds on

Every guide above this one assumes the Part 2 skills you just earned. Here's the direct mapping, so you can see you're genuinely ready.

Modern Web Dev — tonyx1998.github.io/modern-web-dev-guide

Build sites and apps people use in a browser. It builds directly on:

• Functions and control flow — a web app is functions reacting to requests and clicks.
• JSON and APIs — web apps serve and consume JSON endpoints all day (your JSON lesson is the on-ramp).
• Classes and objects — request and response objects, framework models.
• Running Python locally — every project starts with a venv and pip install (that lesson is the prerequisite).

Modern AI — tonyx1998.github.io/modern-ai-guide

Build with large language models, RAG, and agents. It leans hardest on:

• JSON and APIs — calling a model is send a request, get JSON back, pull the answer out — exactly the JSON/API lesson.
• Classes and objects — you create an SDK client object and call methods on it; reading that code is the whole point of the OOP lesson.
• Modules, files, and exceptions — pip install the SDK, read prompt/data files, wrap the network call in try/except.
• Dictionaries and comprehensions — an agent is conditionals and dicts wrapped around a model call.

Modern Security — tonyx1998.github.io/modern-security-engineer-guide

Learn how systems are attacked and defended. It builds on:

• Files, strings, and exceptions — inspecting inputs, parsing logs, handling malformed data safely.
• Modules and the standard library — security tooling is import-and-use, plus packages from PyPI.
• JSON and APIs — reading and probing the requests and responses systems exchange.

SWE Interview Guide — swe-interview-guide.vercel.app

Drill the coding interview: data structures, algorithms, Big-O, system design. It picks up exactly where Part 1 ended:

• Lists, dicts, sets, and strings — the raw material of nearly every interview problem.
• Functions, loops, and the debugging loop — an interview problem is a list, a loop, and a clear head when something breaks.

It assumes you can already write basic Python (everything in Part 1) and takes you to job-ready, with runnable challenges and a final-boss capstone.

Prove it — ship real projects

Reading and quizzing prove you understand; shipping proves you can build. Turn the capstone and the small programs you wrote into projects you can show — put them on GitHub (you learned exactly how in Version control with Git and GitHub), deploy them, and let them anchor your portfolio. A handful of finished, working projects says more to an employer than any certificate.

Why it matters

Every path above reuses what you just learned. You are not starting over at the next guide — you are adding a specialty on top of a foundation you already own. The web app, the AI agent, the security tool, the interview problem: each is the same handful of skills — functions, containers, objects, JSON, files, error handling — assembled for a new purpose.

:::warning Common pitfall Jumping to a framework or a clever algorithm before the basics are automatic. If loops, functions, reading a traceback, or parsing some JSON still feel effortful, build two or three small programs on your own machine first. Speed on the fundamentals is what makes everything above feel easy instead of overwhelming. Go back to debugging any time you feel shaky. :::

That's the whole course. You started at zero and you can now write, read, debug, and build real Python. Pick a guide above, set up a venv, and build something. Nicely done. 🎉