Computer Science Self Study Roadmap: 24 Months, 6 Stages
9 min read
Key takeaways
- Structure a CS self-study plan as six four-month stages in strict prerequisite order: programming, math, data structures, algorithms and theory, systems, then a capstone.
- Budget 8-12 hours per week; below 6 hours the prerequisite chain stalls and the plan stretches past 24 months.
- Clear three math gates before algorithms: discrete math, basic calculus, and enough linear algebra to read matrix notation.
- Attach a build-something exit test to every stage, such as a truth-table evaluator after discrete math or a schema you design and query after databases.
- Cut study volume when life gets busy, never the order, because skipping ahead breaks the prerequisite chain you pay for later.
A computer science self study roadmap works best as six semester-sized stages over 24 months, each with one textbook, one free course, a weekly hour budget, and a build-something exit test before you move on. This one maps a real CS degree's core curriculum in strict prerequisite order, so you always know what to learn next and when you're actually ready.
What order should you learn CS topics in when self-studying?
Self-study computer science in this order: programming basics, then the math those courses assume, then algorithms and data structures, then systems (operating systems, networks, databases), then theory of computation, then a capstone project that forces everything together. Skipping a stage shows up later as a wall you can't climb.
The six-stage sequence
- Programming fundamentals — one language, deeply (Python or C).
- Discrete math and probability — the language every later course speaks.
- Algorithms and data structures — MIT's 6.006, free on OpenCourseWare, is the standard here (course page).
- Systems — OS, networking, distributed systems (the 6.824 equivalent).
- Theory — computability, complexity.
- Capstone — build something that uses stages 1–5.
Why order matters more than resources
The internet has unlimited free courses and one scarce resource: your weekly hours. A brilliant systems course is wasted if discrete math is shaky, because proofs will feel like noise instead of structure. Test yourself at each exit point before moving on — predict, then check, and be surprised where you're wrong. That's the same habit that gets Italian med students through the semestre filtro: 31 questions, 18/30 to pass, no guessing. If you want to feel that loop on a smaller topic, try this interactive lesson on the science of headaches — almost like solving a puzzle, and unintimidating by design.
How many hours per week does a 24-month CS self-study plan need?
Plan for 8–12 hours per week. At that pace, the roadmap fits six semesters of roughly four months each, mirroring a real degree's rhythm. Below 6 hours the prerequisite chain stalls; above 15 you burn through material faster than it consolidates.
Hour budgets per stage
Early stages need less time because topics are narrower; later stages (systems, algorithms practice) need more. These budgets are illustrative, not measured.
| Stage | Focus | Hours/week | Months |
|---|---|---|---|
| 1 | Math foundations | 8–10 | 4 |
| 2 | Programming basics | 8–10 | 4 |
| 3 | Data structures | 10–12 | 4 |
| 4 | Algorithms + theory | 10–12 | 4 |
| 5 | Systems | 10–14 | 4 |
| 6 | Projects + review | 8–12 | 4 |
What to cut when life gets busy
Cut volume, never order. If you have 4 hours one week, do 4 hours of the current stage; skipping ahead to something fun breaks the prerequisite chain and you pay for it two stages later. Track progress like an exam countdown — mancano 39 giorni works as motivation in CS too. Test yourself weekly with predict-then-check exercises, the same way an interactive experience like Morlex's Realism and Naturalism walkthrough makes you guess before revealing. Be surprised, then adjust.
What math prerequisites come before algorithms and data structures?
Three gates, in order: discrete math, basic calculus, and enough linear algebra to read matrix notation without flinching. Skip them and Big-O proofs, graph algorithms, and dynamic programming turn into memorisation instead of reasoning.
Discrete math first
Proofs, sets, logic, and combinatorics are the language algorithms are written in. MIT's free Mathematics for Computer Science course on OCW covers exactly this, and it is the gate most self-taught roadmaps wave you through too fast. Budget 6–8 hours a week for 8–10 weeks, and treat the problem sets as the exit test: if you can prove something by induction without checking notes, move on.
How much calculus you actually need
Less than you fear. Limits, derivatives, and basic integrals cover asymptotic analysis; you do not need multivariable tricks. If you already survived chemistry and physics for the semestre filtro, this is review, not new ground.
Test yourself the way you'd test anything else: predict what a proof will do next, then check. When a topic like reaction kinetics becomes interactive on Morlex, the same predict-then-verify habit works for limits and sums, and it is far less intimidating than a 400-page textbook.
Which books cover each stage of a self-taught CS curriculum?
Each stage needs one main book and one free course, in strict prerequisite order. Pick the book first, then use the course to check you can actually solve problems, not just read.
Stages 1-2: programming and math books
Stage 1 uses Python Crash Course (Eric Matthes) paired with MIT's 6.0001 on OpenCourseWare. Stage 2 is math: Discrete Mathematics and Its Applications (Rosen) plus the MIT 6.042J lectures. If you want a lighter warm-up before Rosen, work through Brilliant's interactive logic and algebra paths, or turn a topic you find dry into an interactive lesson, like the solar system experience, which shows how a concept you can poke at sticks faster than one you only read.
Stages 3-4: algorithms and systems books
Stage 3 is Algorithms (Sedgewick and Wayne) with the Princeton Coursera course. Stage 4 is Computer Systems: A Programmer's Perspective (Bryant and O'Hallaron) with CMU's 15-213 labs, which are freely available.
Stages 5-6: theory and capstone books
Stage 5 is Introduction to the Theory of Computation (Sipser) with Stanford's CS154 notes online. Stage 6 has no single book: build a compiler, database, or interpreter from scratch, using Crafting Interpreters (Nystrom) as the most common capstone template.
Exit criteria for each stage appear in the next section.
How do you know when you're ready to move to the next stage?
Treat each stage like an appello: a fixed threshold you either clear or you don't. The OSSU curriculum maps its courses to a real degree sequence, and it expects you to pass assessments before advancing, not just watch lectures.
Build-something exit tests
For every stage, build one small thing that only makes sense if you understood the material. Finish discrete math? Write a truth-table evaluator. Finish databases? Design a schema and query it. If the build takes more than a weekend of confusion you can't resolve, you're not ready.
Scoring yourself like an exam
Give yourself 31 questions on the stage's core topics and demand an 18/30 before moving on, the same threshold Italian filter exams use. Predict your answers first, then test and be surprised. Working through something like how the internet works interactively is an honest check: if you can't explain each layer, the score was luck.
What do self-taught programmers on Reddit say is missing from most roadmaps?
Three gaps come up again and again in computer science self study reddit threads: projects, debugging, and consistency.
The project gap
Roadmaps list books and courses but rarely force you to build anything. Reading SICP or watching a lecture feels like progress; writing a working program proves it. Redditors who finished a curriculum without projects report the same thing: they could explain concepts but freeze when facing an empty editor. Fix it by attaching one small project to every stage, not just at the end.
The consistency gap
The second complaint is that roadmaps assume unlimited motivation. A 24-month plan with no weekly hour budget collapses the first time exams, work, or life interrupt it. People who finish treat study like an appello: a fixed weekly commitment, tracked, with a predictable number of sessions. Miss one, reschedule it. The plan survives; the streak matters less than the hours logged.
How does a CS roadmap differ from a data science self-study roadmap?
Shared foundations
Both paths start identically: Python basics, discrete math, linear algebra, probability, and statistics. For roughly the first six months the two roadmaps overlap almost completely, and switching between them costs little. That shared block is also where most people quit, which is why threads on r/learnprogramming keep pointing out that roadmaps list topics without sequencing them or setting exit criteria.
Divergence point
CS then splits toward systems: data structures, algorithms, computer architecture, operating systems, networks, and databases, with C and a compiled language. Data science pivots toward pandas, SQL, visualization, machine learning libraries, and experimental design instead. In practice, the CS path teaches you to build software; the data science path teaches you to interrogate data with software built by others. Choose by asking which failure you'd rather debug: a segfault or a biased model.
Which tools make a self-study plan stick?
Criteria for a study tool
A tool earns a slot in your weekly budget only if it does three things: gives you immediate feedback, matches the stage's exit criteria, and stays fun enough that you return after a bad week. Anything that just hands you answers fails the first test.
Where each tool fits, and where Morlex doesn't
Brilliant.org suits stages 1–2 math; PhET's simulations make physics and CS-relevant concepts interactive; Quizlet works for spaced repetition of syntax and definitions; NotebookLM helps summarise dense textbook chapters.
Morlex AI fits the same pattern: turn any question into an interactive experience, predict, test, be surprised. It's unintimidating, almost like solving a puzzle, and gamified enough to burn through dry material fast.
Where it falls short: it won't enforce your prerequisite order or check exit criteria for you, and it has no structured curriculum. It's a practice layer on top of the plan, not the plan itself.
FAQ
Can I self-study computer science without a degree and get a job?
Yes, but the roadmap alone won't hire you. Employers respond to proof: the capstone project, a public GitHub with builds from every stage, and the ability to explain what you built. A rigorous plan with exit tests replaces the degree's structure, and shipped projects replace the credential.
Is 2 years enough to self study computer science?
Yes, at 8-12 hours per week. That pace fits six four-month stages covering the core degree curriculum: programming, math, algorithms, systems, theory, and a capstone. Below 6 hours weekly the prerequisite chain stalls and the plan stretches well past 24 months. Two years is enough if the hours are consistent.
What programming language should I start with in a CS self-study plan?
Python or C, and pick one to learn deeply rather than sampling several. Python lowers the barrier for stage 1 and pairs with MIT's 6.0001; C pays off later in systems courses. The stage 1 book, Python Crash Course, assumes no prior experience, so either choice works if you commit to it.
Do I need a degree-level math background before starting a computer science self-study roadmap?
No, but you need it before algorithms, not before day one. Stage 1 is programming; stage 2 builds discrete math, basic calculus, and enough linear algebra to read matrix notation. Limits, derivatives, and integrals are enough for asymptotic analysis. The math gate comes at stage 2, not the start.
How do I stay motivated during a 24-month self-study plan?
Treat it like a fixed weekly commitment, not a motivation problem. Budget 8-12 hours, track sessions, and reschedule misses instead of abandoning the week. Motivation follows visible progress: clear each stage's exit test, build something small that proves you understood the material, and log the hours.