A 90-Day Plan for Learning to Code
Ninety days will not make anyone an expert. It is long enough to build a habit, finish a few small programs, and know whether you want another ninety. This plan is a weekly structure for fundamentals, tiny projects, reading other people’s code, a simple portfolio, and staying out of tutorial hell — the loop where you watch another intro instead of writing a messy file of your own. It assumes a few hours on most weekdays, not a fantasy of eight-hour days after a full-time job. Adjust the clock; keep the order. No salary claims, no school pitches.
How to use the twelve weeks
Pick one first language using choosing your first programming language and do not switch in week two because a video thumbnail shouted. Python is the default in the sketches below; if you chose JavaScript, keep the same kinds of exercises in the browser.
Each week has: a small amount of concept time, a program you run, and a short write-up (even five lines in a text file) of what broke. The write-up is for you. Commit when something runs, using Git as soon as it is installed.
Rest days count. A plan you can resume on Monday beats a streak you abandon after a missed Thursday.
Weeks 1–3: fundamentals
Week 1. Install the language. Run a file. Print, variables, input, types. Read the basics of instructions and variables, then complete your first Python program, including the guessing game. Break it on purpose and read the errors instead of closing the terminal. End the week with the game running from a saved file, not only from memory in an interactive shell.
Week 2. Conditions and loops until they are boring. Write: a program that grades a score into bands, a program that sums numbers until the user types 0, a program that prints a multiplication table for one integer. No new libraries. If you cannot explain a loop out loud while pointing at the condition, do not add lists of lists yet.
Week 3. Functions and lists (or arrays). One function, one job. Write a grocery-list script: add items, show items, quit. Then extract “show items” into a function. Read the official tutorial chapter on lists once, slowly, with the interpreter open. Skip the rest of the language reference.
Weeks 4–6: small projects
A project here is a program you could demonstrate in five minutes, with a README that says how to run it. Not an app store product.
Week 4. Text tools. Examples: count words in a file you pass as an argument; convert a CSV of expenses to a printed total by category; a quiz that reads questions from a file. Practice reading paths and files. Handle a missing file with a clear message instead of a raw traceback if you are ready; if not, a traceback you understand is still progress.
Week 5. A slightly larger guessing-style game or a choose-your-own-text adventure with functions per room. Or, for JavaScript, a page with a button that updates a total. If the web is your track, learn how browsers, URLs, and HTTP fit together this week so HTML/CSS/JS have a map.
Week 6. Polish one project: README, example input, Git history that is not one giant dump. Ask someone to run it from your instructions only. Fix the instructions. That social test is more valuable than a new framework.
If a project grows fangs, cut scope. A finished quiz beats an unfinished “platform.”
Weeks 7–9: reading code and slightly harder problems
Reading code is a skill. Spend part of each session on someone else’s small file: a short standard-library example, a tiny open-source script, or a classmate’s repo. Do not start with a huge application. Trace one function. Predict the output, then run it.
Week 7. Debugging week. Take an old project, add a feature, use Git to revert when it explodes. Write down three errors you hit and what the last traceback line meant.
Week 8. Data in, data out. Parse a simple format you control (a text file with one record per line). Produce a summary. Avoid downloading a machine-learning library “to try AI.” That is usually tutorial hell in a new hat.
Week 9. Either a second language hello (JavaScript if you started in Python, or the reverse) limited to variables, if, and a loop, or a deeper pass on your main language (dictionaries/maps, reading JSON). One extra language is enough. The point is to see the same ideas in new spelling, not to collect logos.
Weeks 10–12: a small portfolio and a next step
A beginner portfolio is two or three repositories with READMEs a stranger can follow, plus links to the running instructions. It is not a custom animated homepage. If you want a page later, a single HTML index of links is enough.
Week 10. Choose your two best small projects. Clean them. Remove commented-out experiments. Add a “what I would do next” section so you remember they are learning pieces, not abandoned wrecks.
Week 11. One new project that uses everything: functions, a file or a page, an error path, Git commits as you go. Keep it in the domain you care about (a shop hours helper, a study timer, a static page of family recipes with a little script). Motivation is part of the plan.
Week 12. Review. What still feels foggy? Re-do week 2 exercises without looking. Write a short note: continue this language, add web, add data, or pause. Pausing is allowed. Another ninety days is allowed. Shopping for a new “complete bootcamp in a banner ad” is not a week-12 task.
Avoiding tutorial hell
Symptoms: many half-watched courses, no repo of your own, comfort only when a narrator is talking, panic in a blank editor. Antidotes:
- For every thirty minutes of video or reading, spend at least thirty minutes in a file you typed.
- Close the tutorial and recreate the exercise from the idea, not from pause-and-copy.
- Limit yourself to one primary text or docs set per week.
- When a lesson adds a library you cannot explain, skip it until a project needs it.
- If you are bored repeating basics, make the same program about a topic you like — do not skip the basics for a framework.
Copying is allowed as a first pass. The test is whether you can change a rule (tries_left from 3 to 5, prices in a different currency label) without the video. If you cannot, you watched; you did not learn yet. Try again with the video closed.
Weekly rhythm (a template)
- Two or three weekday sessions: 40–90 minutes. Start by running yesterday’s file.
- One session that is only practice, no new concept.
- One short write-up: error, cause, fix.
- A commit when something works.
- A weekly stop: no new topic after your cutoff, only notes for next week.
If you miss several days, do not “catch up” by watching six videos at 2× speed. Repeat the last exercise you completed, then take the next small step. The calendar is a servant.
People around you may move faster. Their timeline is not information about your brain. It is information about their hours and prior exposure. Compare to your week-1 folder instead.
Checklist
- One language for the first month; Git installed before the first refactor.
- Weeks 1–3: syntax and small drills until loops are dull.
- Weeks 4–6: finished tiny projects with READMEs another person can run.
- Weeks 7–9: read code, debug on purpose, optional second spelling of the same ideas.
- Weeks 10–12: tidy two projects, build one more, decide the next ninety days.
- Match every lesson with time in your own files; that is how you leave tutorial hell.
Start week 1 with a folder, a file, and a program that prints your name. Everything in this plan is that gesture, repeated, with slightly richer instructions. The magic is not the calendar. The magic is the files you can still run in December.
Related lessons
Beginner-level guidance; tools and versions change, so check official documentation for details.