🧠 CS & Interviews · skill roadmap · updated for 2026

Computer Science Fundamentals Roadmap

Strong computer science fundamentals are what separate developers who can use a framework from engineers who can debug, optimise and design systems. This free computer science roadmap covers the topics in a CS degree that matter most in real jobs and coding interviews — complexity analysis, data structures, algorithms, operating systems, computer networks, databases and software design — in a practical order.

20steps in 6 stages
17free lessons · 115 min read
~220 hstudy & practice
4–6 monthsBeginner → Advanced
0%
Your progress
0 of 17 lessons
Saved in this browser — no account needed.
Next up · step 1 Big-O & Complexity Analysis → 🎉 Every lesson done — take a Skill Forge test below!
By the end you'll be able to:
  • ✔Analyse time and space complexity with Big-O notation
  • ✔Choose and implement the right data structure for a problem
  • ✔Solve interview problems with recursion, backtracking, DP and graph algorithms
  • ✔Explain how operating systems, networks and databases work under the hood
  • ✔Design maintainable code with SOLID principles and design patterns

The roadmap

1
Stage 1 of 6 · 2 steps

Foundations

  1. How to read nested loops and recursive calls, amortized analysis of dynamic array append, and worked Big-O walkthroughs.

    Start lesson →
  2. Discrete Mathematics for Programmers Coming soon

    We're writing this lesson — learn it in a mentor-led program meanwhile.

Stage 1 project · add it to your portfolio

Complexity cheat sheet

Benchmark linear vs binary search and bubble vs merge sort on growing inputs and plot the results.

2
Stage 2 of 6 · 3 steps

Data structures

  1. How hashing, buckets, and collisions work, average vs worst-case complexity, and solving two sum with a hash map.

    Start lesson →
  2. Tree terminology, BST insert/search/delete, the four traversal methods, and when a BST degrades to O(n).

    Start lesson →
  3. Track connected groups in near-constant time with union by rank and path compression — and solve classic graph problems with it.

    Start lesson →
Stage 2 project · add it to your portfolio

Build your own collections

Implement a dynamic array, hash map, binary search tree and min-heap from scratch with tests.

3
Stage 3 of 6 · 5 steps

Algorithms

  1. Bubble sort, merge sort, and quicksort with full code, a complexity/stability comparison table, and when to just use sorted().

    Start lesson →
  2. The backtracking template — choose, explore, un-choose — applied to subsets, permutations and N-Queens, with pruning.

    Start lesson →
  3. What makes a choice greedy, a coin-change counterexample where greedy fails, and activity selection solved correctly with greedy.

    Start lesson →
  4. Overlapping subproblems and optimal substructure, top-down vs bottom-up on climbing stairs, and 0/1 knapsack solved with a table walkthrough.

    Start lesson →
  5. Dijkstra's algorithm for weighted shortest paths, when to reach for Bellman-Ford instead, and a complete Union-Find implementation.

    Start lesson →
Stage 3 project · add it to your portfolio

50-problem sprint

Solve 50 classic problems grouped by pattern (two pointers, BFS/DFS, DP) and keep notes on each pattern.

4
Stage 4 of 6 · 5 steps

Systems

  1. Computer Architecture Coming soon

    We're writing this lesson — learn it in a mentor-led program meanwhile.

  2. What an operating system does, kernel vs user mode, system calls, and the difference between processes and threads.

    Start lesson →
  3. Race conditions, mutexes, semaphores, the producer–consumer problem, and the four conditions for deadlock — with Python demos.

    Start lesson →
  4. Stack vs heap, paging, page tables, virtual memory, page faults and page replacement algorithms like LRU and FIFO.

    Start lesson →
  5. How data travels across networks, the OSI and TCP/IP layer models, packets, encapsulation and the role of each layer.

    Start lesson →
Stage 4 project · add it to your portfolio

Mini shell

Write a tiny shell that runs commands, pipes and background jobs — then explain what the OS did for each.

5
Stage 5 of 6 · 2 steps

Data & design

  1. Why schema design matters and the process: identifying entities, relationships, and constraints.

    Start lesson →
  2. Single responsibility, open/closed, Liskov substitution, interface segregation and dependency inversion — with before/after code.

    Start lesson →
Stage 5 project · add it to your portfolio

Refactor kata

Take a messy script, design its schema properly and refactor the code with SOLID principles and two design patterns.

6
Stage 6 of 6 · 3 steps

Beyond the basics

  1. How distributed nodes agree despite failures — Raft leader election and log replication, Paxos in brief, and where this shows up in etcd and ZooKeeper.

    Start lesson →
  2. Compilers & Theory of Computation Optional Coming soon

    We're writing this lesson — learn it in a mentor-led program meanwhile.

  3. Commonly asked algorithms interview questions with clear, practical answers.

    Start lesson →
Stage 6 project · add it to your portfolio

Key-value store

Build a replicated key-value store and explain what happens when a node fails.

🏁

Finish line: prove it

Finished the roadmap? Turn it into proof employers trust.

🏆 Earn a free Skill Forge certificate

🧭 Where to go next

Computer Science Fundamentals Roadmap FAQ

Do I need a computer science degree to become a software engineer?
No. Many engineers are self-taught or come from bootcamps. What employers test is the knowledge — data structures, algorithms, and how systems work — which you can learn for free by following this roadmap and practising problems.
Which computer science topics matter most for coding interviews?
Big-O analysis, arrays and hash tables, trees and graphs, recursion and backtracking, dynamic programming and graph algorithms come up most. Operating systems, networking and database questions are common in backend and campus placement interviews.
What order should I learn computer science fundamentals in?
Start with complexity analysis, then data structures, then algorithms that use them. Next learn how computers run your code — operating systems and networks — followed by databases and software design. That order lets each topic build on the previous one.
How long does it take to learn CS fundamentals?
With 1–2 hours a day, most learners cover this roadmap in 4–6 months. Data structures and algorithms take the longest because they need regular problem-solving practice.

Keep going after this roadmap

See all 14 roadmaps →