Software Engineer Roadmap — From Beginner to Hireable
Software engineer roadmap from beginner to hireable: programming, CS basics, data structures and a real project. Kaidoro adapts it to your background and deadline.
This is a starting point — make it yours
Use this goal to build your own roadmap — tailored to you and starting fresh.
Programming fundamentals
One language, properly, before anything else. Every later phase assumes you can read and write code without thinking about it.
Get fluent in one programming language~20h
Pick Python — or a language a friend already uses — and commit to it for the whole roadmap. Variables, control flow, functions, collections, files, errors, modules.
Done when: you can write a 200-line program without looking up syntax.
Build a command-line tool you'd actually use~10h
A file organiser, a habit tracker, an expense splitter. Read and write files, handle bad input, fail helpfully rather than with a traceback.
Done when: it runs end to end and reports its errors in plain words.
Learn how a computer runs your code~8h
What a process is, how memory and the CPU work, and how source becomes instructions. Enough to debug without guessing.
Done when: you can explain what happens between running a program and it printing output.
Understand how the web works~6h
HTTP, DNS, clients and servers, and what a URL actually does. Every software job touches this.
Done when: you can explain what happens when you type a URL and press Enter.
Data structures and algorithms
The thinking behind hireable software engineering. Interviews test it directly, and so does any codebase with real data in it.
Learn the core data structures and their costs~15h
Arrays, linked lists, stacks, queues, hash tables, trees, graphs. For each: how insert, delete and lookup behave, and when to pick it.
Done when: you can give the costs of each structure and justify a choice for a real problem.
Learn the standard algorithms and Big-O~15h
Searching, sorting, recursion, and how to analyse a solution's time complexity. This is the vocabulary interviews assume.
Done when: you can hand-trace a binary search and say why one solution beats another.
Practise problems on a real platform~20h
Twenty-five problems across the common patterns, solved without looking at the solution first. Explain your approach before coding it.
Done when: you can recognise the pattern in an unseen problem and sketch the approach.
Implement one data structure from scratch~10h
A hash table or a binary search tree, with tests. Building one from nothing is where the abstraction stops hiding from you.
Done when: it passes your tests and you can explain each design decision.
Git, testing and tooling
The professional habits that turn code into something a team can build on. Interviewers notice these first.
Learn Git properly~8h
Init, commit, branches, merging and resolving conflicts. Panic-free version control is non-negotiable on day one of a job.
Done when: you can recover from a bad merge without deleting the folder.
Set up a workflow that doesn't fight you~6h
An editor you know, a terminal, a linter and formatter, and a repeatable way to start a new project. Remove every decision that happens twice.
Done when: you can scaffold a fresh project and run its tests in under ten minutes.
Write tests that catch real bugs~10h
Unit tests for the logic that matters, run constantly. Test the behaviour a user sees, not the implementation.
Done when: deliberately breaking a function makes a test fail.
Learn to debug systematically~8h
Read the error, reproduce it, isolate the cause, fix it, prove the fix. A debugger beats print statements for most real problems.
Done when: you have fixed a bug you could not see at first and can explain the process.
Build and ship a real project
The single thing that separates candidates: a project a stranger can actually use, live on the internet and documented.
Scope a project small enough to finish~3h
One sentence for what it does, and an explicit list of what you are not building. Most abandoned projects were too big on day one.
Done when: you can describe the project in one sentence and name its not-in-v1 list.
Build the core feature end to end~25h
The one thing the project exists to do, from input to stored result to visible output. No styling and no edge cases yet.
Done when: a stranger can perform the core action without you explaining anything.
Make it survive a stranger~12h
Empty input, enormous input, refreshing mid-action — and a readable message instead of a stack trace. Handle the three common breakages.
Done when: all three produce a sensible message rather than an error page.
Put it live and write a README that sells it~8h
A live URL, automatic deploys from your repo, and a README with what it does, a screenshot and how to run it locally.
Done when: you can send someone a working link and they understand the project in 30 seconds.
Interview prep and job search
Getting hired is a separate skill from the work. This phase is deliberate practice at the format, not more studying.
Learn the coding interview patterns~15h
The handful of patterns that cover most problems — two pointers, sliding window, recursion, hashing, graph traversal. Recognise them rather than memorising answers.
Done when: you can name the likely pattern for a new problem before solving it.
Drill timed mock interviews out loud~15h
Explain your approach as you code, on a timer, ideally to a friend. Thinking aloud under pressure is trainable and is what the interview actually measures.
Done when: five timed sessions are done and you can explain your approach while coding.
Prepare your stories and project pitch~6h
A two-minute project pitch and three behavioural stories — a conflict, a failure, a decision under uncertainty. Rehearse each until it is under two minutes.
Done when: you can deliver the pitch and all three stories without notes.
Run a real job search~10h
A CV tuned to the role, three tailored applications a week, and a tracker. Apply early — interviews are practice, and the first ones will be the worst.
Done when: ten applications are sent and at least one interview loop is complete.