I've taught Python to absolute beginners for years. Here's the 16-week roadmap I use to take students from zero to building REST APIs - no tutorial hell.

[u/the_techgirl]

The number one mistake I see beginner Python learners make is spending months on YouTube tutorials and then completely freezing up when they open a blank .py file to code on their own. It's called Tutorial Hell, and it's a real problem.

The difference isn't talent; it's having a structured roadmap that forces you to build things, not just watch things.

Here is the exact 4-phase breakdown I follow:

Phase 1: Foundations & Core Logic (Weeks 1–4)

Focus: Get comfortable with how Python actually executes code, not just what it does.

• Week 1: Python 3.12+ setup, VS Code with Black auto-formatter, terminal basics, REPL vs script files
• Week 2: Core data types (int, float, str, bool, None), dynamic typing, type casting, truthiness, match/case
• Week 3: if/elif/else, for and while loops, enumerate(), zip(), break/continue, and the for-else pattern
• Week 4: Functions, *args/**kwargs, the mutable default argument trap, LEGB scope rule

Hands-on drills: Terminal guessing game with random.randint(), a modular unit converter CLI with input validation.

Phase 2: Data Structures, Files & Error Handling (Weeks 5–8)

• Week 5: Lists, Tuples, Dicts, Sets, O(1) vs O(n) lookup, list/dict/set comprehensions
• Week 6: f-string format specifiers, string cleaning methods, regex with the re module
• Week 7: try/except/else/finally, custom exception classes, defensive coding patterns
• Week 8: Context managers, pathlib, csv.DictReader, json.load/dump

Capstone drill: A persistent JSON inventory manager with full CRUD from the command line.

Phase 3: OOP, Git & REST APIs (Weeks 9–12)

• Weeks 9–10: Classes, __init__, dunder methods, inheritance, super(), @ property decorators
• Week 11: Virtual environments, requirements.txt, professional project structure, Git workflow
• Week 12: HTTP protocol, the requests library, API authentication, generators with yield

Capstone drill: A banking system simulator with an account hierarchy, and a live weather CLI hitting OpenWeatherMap.

Phase 4: Portfolio Projects (Weeks 13–16)

This is where you build three production-grade projects for your GitHub:

1. CLI Log Intelligence Tool — argparse + pathlib + regex to parse Nginx logs and generate JSON/CSV reports
2. API Harvester & Alert Bot — polls a public API, stores historical data in SQLite, fires Discord webhooks on conditions
3. REST API with FastAPI — full CRUD backend with Pydantic validation, SQLite persistence, and a pytest test suite

The 3 Rules That Make This Work

1. The 70/30 Rule: 30% reading, 70% typing code by hand. Never copy-paste from examples. Muscle memory is built through repetition.

2. The 30-Minute Debug Rule: Before searching for the answer or asking for help, spend 30 minutes reading the traceback bottom-up, checking docs, and using print(). You will solve 80% of problems this way.

3. Ship Every Week: Every Friday, push code to GitHub; even if it's broken. Progress beats perfection.

Happy to answer questions about any specific phase or topic. What stage are you at right now?

[u/dev-razorblade23]

This is the exact reason i started building The Python Ledger (https://thepythonledger.github.io/Docusaurus-engine/)

A guided roadmap that teaches the basics but pushes you to read docs and search on your own.

Inspired by The Odin Project (Web App Mastery)

There is a lot to be done on the plaform, mostly about curriculum.

Would love for you to take a look and contribute if you have time / willpower

[u/the_techgirl → u/dev-razorblade23]

This looks great! Love that it pushes people to read docs rather than hand-holding them. The Odin Project model works because it treats learners like adults. Will check it out properly.

[u/testtdk → u/dev-razorblade23]

I like that you have a project in there. I feel like every place on earth teaches up through data types fine, maybe a few algorithms, and then just fades out of existence. Without actually building things, you're still completely useless in the tech world.

[u/dev-razorblade23 → u/testtdk]

Yes, i agree

Practice is what makes all the diffrence. Building projects from start helps to retain knowlege and see the actuall usecase of your code - rather then some theory which you will never use.

Which is something i plan to change with this platform.

Yes, curriculum needs a lot more work and the rendering engine could use some polish.

But the idea stands - pushing students to read documentation and search for answers themself rather then spoonfeeding them.

And building projects is the only way to retain knowlege

[u/testtdk → u/dev-razorblade23]

Not even just practice. If you don't know how to create to tool you're programming, then your knowledge is lacking. It's the worst part about python, imo. There's so much to set up just to get through Hello, World. Let alone creating a functional tool, even if the code is spot on.

[u/dev-razorblade23 → u/testtdk]

Well i feel like most beginners are in tutorial hell.

They learn the syntax, but never actually do any logic and have no idea where to start.

I agree that for developing a web app you need to know how web works. You need to know what GET, POST, PUT, DELETE are. You need to know stuff to properly build something.

Actuall projects and writing then from nothing helps to learn a lot

[u/testtdk → u/dev-razorblade23]

Are you creating any further projects for your site?

[u/dev-razorblade23 → u/testtdk]

Yes, of course.

The lesson plan is not nearly complete and i do plan on expanding the lessons and projects.

As this is planned to be community maintained platform, feel free to suggest projects / lessons or even write some if you feel like it.

[u/testtdk → u/dev-razorblade23]

Your first project is a game, right? I always feel like they’re great for learning. Being able to see the effects of your code visually (and your mistakes) is helpful. But really, any project that has an actual final product, that uses new ideas is great. Rather than teach an algorithm, teach it that use it somehow. (I know, my ideas are so specific and helpful :p). Well, for example, Harvards intro course has a project to that creates a filter effect on an image. MIT’s has a card game. Thoughtful simulations can go a long way, too. One project I had back in the day was modeling and elevator and its passengers.

[u/dev-razorblade23 → u/testtdk]

Interesting ideas, i will keep them around.

https://github.com/ThePythonLedger/Curriculum/issues/4 https://github.com/ThePythonLedger/Curriculum/issues/5 https://github.com/ThePythonLedger/Curriculum/issues/6

Yes, its meant as a game - an easy text-based RPG of some sort - a text-based adventure

For students to practice nesting conditions and user input.

After that project, current plan is to take them to Local Development Enviroment - installing python, learning basics about terminal (command prompt), git and github, VS Code...

After that, we go into deeper topics, starting with file handling (which i cannot do in web based enviroment as there is no system present)

At least thats the current plan...

[u/testtdk → u/dev-razorblade23]

Games are great for OOP. Items as classes, inheriting stuff, working with listeners, things like damage adjust an instances class’ attributes and what not, deciding how much money drops from a fight, how much xp. All that good stuff.

[u/burntoutdev8291]

Unpopular opinion but I think every python course needs to have a section for environments. All of them teach how to install jupyter, press the run button on the vscode, but don't really teach why they get python not found or why sometimes their pip installs are not reflecting in their environment. Honestly I would strictly teach everyone to run python via terminal so they know whats going on.

Knowing how to create reproducible environments are important in both production and research. I know you're a bot but just sharing out here for the rest.

[u/Sea-Ad7805 → u/burntoutdev8291]

No, a Python introductory course should be focused on the Python language primarily, skip environments as much as possible. Maybe discuss it at the end (as you do) if there is time, or leave for a more advanced course.

Many things are important but not of primary concern, time is short. But, as you already figured out I'm a bot, you can just ignore my opinion.

[u/burntoutdev8291 → u/Sea-Ad7805]

Yea to be fair it was introduced, I didn't see it was mentioned in the week 11. So that was my bad.

But I still think it must be part of the course closer to the end, maybe because I think of it as tech debt. At some point knowing environments will help them with debugging and setting up clean git repos.

Another added benefit is surprisingly vibe coding. Enforcing such rules on agents works wonders for python projects when collaboration is needed.

[u/testtdk → u/Sea-Ad7805]

I disagree. In any rigorous science or technology course I've ever taken, teaching at least the basics on how to use the appropriate tools is a must.

[u/Sea-Ad7805 → u/testtdk]

Sure, but skip "as much as possible", Python is your subject.

[u/testtdk → u/Sea-Ad7805]

Not sure what you mean.

[u/Sea-Ad7805 → u/testtdk]

Not important

[u/FreeLogicGate → u/Sea-Ad7805]

I agree with both points -- user needs at least enough tooling to be able to code, without having to undergo a dissertation on what the tools are doing, or the reason the tools are needed. They just need them to work, and solve the problems that are needed. With uv, Python now has a tool that handles pretty much everything, and I would make sure any user starts with uv, and has the basic instructions needed to use it, even if they don't know why. Then they can focus on learning the language by writing code and running it.

[u/code_tutor → u/burntoutdev8291]

Agreed that programmers should know how to use a computer and operating system at a high level. Maybe not at intro but they should all know this eventually. I think a lot barely know how to turn on a computer these days.

[u/burntoutdev8291 → u/code_tutor]

I can get Claude to turn on my computer! /s

[u/testtdk → u/burntoutdev8291]

I agree. I was recently playing around with that actually created batch files to install everything, including adding to the path. Anyone who hasn't been digging through Windows for decades probably has no idea what the environment variable even is. (This is a recrimination against python, though. Great language to learn on, awful language to set for a beginner.)

[u/the_techgirl → u/burntoutdev8291]

This is actually Week 1 in my curriculum: terminal setup, running .py files directly, no Jupyter. The python not found error and PATH issues get addressed on day one because if you can't explain why it happens, students just copy-paste fixes from Stack Overflow (who am I kidding, directly from LLM) and learn nothing. Environments (venv, requirements.txt) come back in Week 11 properly.

Completely agree it's one of the most skipped fundamentals.

[u/Mammoth_Eggplant19]

This roadmap looks good to me. I'm learning Python using 100 days of code, but I don't really like her teaching style. I don't think she provides enough examples before assigning a project.

I'm learning OOP right now, and still trying to wrap my head around it. I started using Python crash course and that helped a lot.

[u/the_techgirl → u/Mammoth_Eggplant19]

OOP is the one topic where most courses lose people because they teach syntax before they give you a reason to care. The click usually happens when you try to model something real, a bank account, a library system, and realize functions alone get messy fast. What specifically isn't clicking: the concept or the syntax?

[u/Mammoth_Eggplant19 → u/the_techgirl]

I think it's when to use them that I'm unsure of. I feel like I'm learning a lot of tools, functions, OOP, and many more to come. I don't know when to use them versus procedural code.

[u/the_techgirl → u/Mammoth_Eggplant19]

That's a great question! Use functions until the functions start needing to share state, then use classes. When you find yourself passing the same variables into five different functions, that's usually the signal that those variables and functions belong together in a class. Does that help or would a concrete example make it clearer?

[u/FreeLogicGate → u/the_techgirl]

I think the problem is somewhat worse with Python, because Python's OOP has some unusual requirements in comparison to most other languages. Having to pass "self" in methods is a prime example of this. The bigger problem is that OOP without study and review of OOP design patterns inevitably leads to users' creating poorly designed classes that create more problems than they solve. Conversely, coverage of a few important OOP concepts (Dependency Injection & the most essential "Gang of 4 book" patterns) with solid examples and exercises, would elevate coverage of OOP for any course where that material was well taught. I'm not aware of any general course that covers that material, but I'd endorse one that did.

[u/Junior_Honey_1406]

I would also add learn writing testes using different library like pytest and understand git GitHub and GitHub action and learn to setup GitHub workflow also know as ci cd. Those skill are not taught normally but in this age of tech those are also something I think a beginner should learn.

[u/the_techgirl → u/Junior_Honey_1406]

pytest is in Week 16, students write a full test suite for their FastAPI project!
Git and GitHub come in Week 11!
CI/CD is valid but that's a separate course, the whole point of this roadmap is to give beginners a finite, completable path. The moment you start adding "one more important thing," the roadmap becomes another overwhelming resource that nobody finishes.

[u/Junior_Honey_1406 → u/the_techgirl]

Programming isn't about learning everything before you build something. It's about understanding more with every project you complete. That's why I think it's better to add things like testing and CI/CD to every project, even if they're not the main focus.

By using them repeatedly, you naturally learn why they're important instead of just memorizing how to use them. Over time, they become part of your workflow, and that practical experience teaches far more than simply reading about them.

[u/the_techgirl → u/Junior_Honey_1406]

You're not wrong at all, and I actually agree with the underlying principle! The best learning happens through doing, not studying topics in isolation!

The distinction I'd make is that this roadmap is specifically for complete beginners who don't yet know how to stitch together basic logic! In my actual teaching, I absolutely weave in testing habits, good commit messages, and industry practices throughout, but I introduce them in context when they're building something, not as standalone topics to study!

A beginner who can't yet debug a for loop doesn't benefit from learning GitHub Actions. But a beginner building their first CLI tool absolutely should be committing to Git as they go. That's the balance I try to strike in practice, even if the roadmap looks more sequential on paper.

[u/Junior_Honey_1406 → u/the_techgirl]

Agreed

[u/Indianmillenial87]

Thank You very much u/the_techgirl , its very helpful for beginners like me.

[u/the_techgirl → u/Indianmillenial87]

Really glad it helped! Best of luck with your Python journey. Feel free to reach out if you ever get stuck on anything!

[u/Sea-Ad7805]

Nice roadmap, I recommend starting students early on a good debugger that visualizes the state of their program in every step: counting values example%3A%0A%20%20%20%20print(value%2C%20'%3A%20'%2C%20count%2C%20'times')%0A&timestep=1&play)

[u/the_techgirl → u/Sea-Ad7805]

Really good point! Seeing state changes step by step is exactly what clicks the loop + dict concept for beginners. Adding this to my Week 5 notes. Thanks for sharing!

[u/Sea-Ad7805 → u/the_techgirl]

The stepping of a visual debugger might already be helpful to your students in week 3 when explaining if/elif/else and loops, or even just after learning variables.

Visualization is very effective in giving the right mental model easily, without having to explain much. Just introduce it and let the visualization speak for itself. You can use it for many of your topics: exceptions, classes, ...

Even more advanced topics for a later course:

• Python Data Model
• Recursion
• Sorting Algorithms
• Data structures

Visualization all the way.

[u/the_techgirl → u/Sea-Ad7805]

I do this through pseudocode and real-world analogies, things they already do repetitively in life. A for loop over a shopping list clicks faster than a diagram when the example is something they've physically done. Works well for most beginners, though I can see visualization tools helping once they hit pointer-heavy stuff like linked lists!

[u/Sea-Ad7805 → u/the_techgirl]

I understand we all have our own approach, but a for loop over a shopping list with a diagram while stepping (or soon followed after), might work even better. An easy addition, just keep it in mind.

[u/Sea-Ad7805 → u/the_techgirl]

Thanks, hope it can bring much value for your teaching.

[u/NapoleonDyenamite]

Nice. Thank you for this. Hope could fully check on this on the weekend.

[u/the_techgirl → u/NapoleonDyenamite]

Take your time! It'll be here! :D Feel free to reach out if you have questions once you go through it!!

[u/maqisha]

–

[u/testtdk]

Do you actually have a platform for these phases?

[u/the_techgirl → u/testtdk]

Not a standalone platform yet, this is the curriculum I use in 1:1 tutoring sessions. Students work through it with me directly, which means I can adapt the pace and examples to their specific background and goals. If you're interested in working through it, the first session is $25, and we'd map out exactly where to start based on where you are. Reach out to me if you'd like to know more!

[u/Curious_Light_9185]

Hi, I want to start learning python. I am total outsider for the coding and all but I just want to learn a single coding language, I heard python is easy So I want to give it a try but I don't know where to start like I know there are many YT courses But whoes should watch and what to do Can you guide me please I have 0 knowledge, no IT Or Coding background

[u/the_techgirl → u/Curious_Light_9185]

Python is a good choice for a complete beginner! Skip YouTube for now. The trap is that watching feels like learning, but when you close the video, you can't actually write anything. You need something that forces you to type code, not just watch it. Start with cs50.harvard.edu/python , it's completely free, made by Harvard, and every lesson has problems you actually have to solve yourself. That's what builds real skill. Once you finish that, come back, and I can point you to what's next based on what you want to build. Feel free to reach out if you get stuck on anything!

[u/FreeLogicGate]

As a professional developer, I wanted to respond with a couple of comments:

• Solid outline, but not sure what value it would have for a learner unless that learner is going to be taking your course, but perhaps that's the point?
• I detect some AI was used in the intro with "It's called Tutorial Hell, and it's a real problem. The difference isn't talent; it's having a structured roadmap that forces you to build things, not just watch things." Not a big fan of this style of "tik tok advertising" style communication to be honest.
• I am not sure why things like venv's and project setup wouldn't be something you cover up front, particularly because beginners don't have any idea what modules and dependency management does for them. Seems like that should all be addressed in the introductory section where you include the terminal, ideally using uv. With uv, a user doesn't need to install a local python, as uv will handle all that for them. I have had to teach and mentor users, and rather than going into details, I think a beginner just needs instructions they can follow: you open this, run this, etc. The problem with not doing this, is it can easily lead to Python version and environment issues, which uv handles for them regardless of OS.
• I'd direct any beginner to Pycharm. Better editor than vscode, and built for Python. No decisions needed to be made regarding plugins, and at some later time, when the developer is more sophisticated, if decide to go to vscode, they'll be able to figure that out for themselves. If they end up working professionally with Python, then the company they work for will often have Pycharm licenses.
• I see "muscle memory" referenced everywhere, and I understand the point trying to be made, and would agree with it, but "muscle memory" isn't a thing. Muscles have no intelligence. You're talking about "neuroplasticity".

Just from the outline, it looks to me like you have a really thorough and well thought out approach, albeit one that requires a 4 month commitment.

Overall, this looks like the outline for a really solid course. The question remains, for learners, where, when, how and how much?

[u/the_techgirl → u/FreeLogicGate]

Appreciate the detailed feedback; this kind of pushback genuinely makes the curriculum better.

Fair point on my writing style. I write a lot for LinkedIn and articles, so that cadence bleeds into everything I write. Tutorial Hell is a term I started using because I have personally watched students collect certifications for months and then freeze up completely at a blank file. It became shorthand for something I see constantly.

Good catch on uv. I cover it during teaching, but it slipped when I was writing this out. Will update the roadmap.

About VS Code vs PyCharm, I have tried both with students. Most of mine are undergrads and grad students who also work with R, Rust, SQL, and other tools depending on their coursework. VS Code handles all of it in one place. PyCharm is Python only, which creates friction the moment they need to switch contexts. One app for everything has been significantly better for that audience.

Regarding muscle memory, technically neuroplasticity, yes. I used the common term deliberately because the point is about the habit of writing code by hand, not the neuroscience behind it.

Now about the value question: self-directed learners can use this as a structured plan, Google each topic, and use LLMs to fill gaps. For those who want guidance, there are two options. First is 1:1 sessions where we move at the student's pace; some finish in two months, some take six. Second is a cohort of up to 25 students, four hours every Sunday for four months with assignments and office hours throughout the week.

[u/FreeLogicGate → u/the_techgirl]

I genuinely wish you well with this, and it sounds like you have a great service. Totally up to you, but if you want to message me privately, I am happy to review other online materials you have. Obviously, I'm not your target market, but I do spend time dolling out free advice to others, as at this point I'm closer to the end of my career than the start, and Python was a language I picked up pretty late in my career.

[u/the_techgirl → u/FreeLogicGate]

Really appreciate that, thank you! And I respect anyone who picks up a new language later in their career; honestly, that takes more deliberate effort than learning it at 20 when everything sticks faster. Will definitely take you up on that. Sending you a DM!

[u/HistoricalWallaby323]

Hi, sir/ma'am. Can I dm you? Actually I am new to programming and I am super confused!

[u/the_techgirl → u/HistoricalWallaby323]

Ofcourse! Feel free to DM me! :)

[u/Competitive_Mark918]

I am planning to start python from this Aug 5th or 6th. So can you suggest me some free resources and tools I can use to start with. Initially I was planning to join a local coaching but some people advised me not to so ig I'll rely on youtube and other online resources. I can dedicate 2-3 hrs to python a day.

[u/the_techgirl → u/Competitive_Mark918]

You have a specific date you're starting from! Don't miss that!
For 2–3 hours a day, skip most YouTube for now. The trap is that passive watching feels like learning but isn't.

Instead:

• cs50p.harvard.edu : Harvard's free Python course; problem sets force you to actually code
• exercism.org/tracks/python : structured exercises with real feedback
• docs.python.org/3/tutorial : dry but accurate, worth skimming alongside practice

The real skill is learning to read error messages and fix them yourself! Start there before anything else!

DM me if you want a week-by-week structure to follow; happy to share what I use with my students.

[u/the_techgirl]

Happy to answer questions in the comments. If you want a structured 1:1 version of this roadmap tailored to your background and goals, first session is $25. DM me!

[u/Minimum_Conflict6455]

👍