The AI Research Roadmap: From Software Developer to AI Researcher, One Step at a Time
There is no shortage of "how to get into AI" content. That is exactly the problem. Ask ten people how to become an AI researcher and you get ten different reading lists, twenty courses, and a vague instruction to "read papers." Most people who want this path do not fail from lack of material — they drown in it. They open five tabs, start three courses, finish none, and quietly give up six weeks later, convinced they were not smart enough.
They were not the problem. The plan was.
This post is the roadmap I built to solve that for myself: a single, opinionated path from working software developer to AI researcher — someone who can read, implement, and eventually publish research. It is deliberately narrow. One route, one resource per step, done strictly in order. I am publishing it, and every lesson behind it, openly so that anyone stuck at the same starting line can just follow the map instead of building their own from scratch.
I want to be honest about where I am on it, because that matters: I am not writing this from the finish line. I have completed the mathematics foundation and I am currently in the data analysis stage. Everything below is the path I am actively walking, not a view from the summit. The full, growing repository is here:
Repository: https://github.com/asadlion11/AI-Research
The Destination, and the Real Path
The goal is specific: become an AI researcher — able to read, implement, and publish research. Not "learn some AI." Not "get an AI job title." Do original work and contribute it back to the field.
That goal is too far to jump to directly, so the roadmap treats it as three stops on one road:
ML Engineer → Research Engineer → AI Researcher
Each stop is a complete, useful identity on its own. If you stop after the first, you are an employable ML engineer. If you stop after the second, you operate like a research engineer. Nobody has to reach the end for the journey to have paid off — and that is what keeps it sustainable.
| Phase | Focus | Rough time | Ends as |
|---|---|---|---|
| 1 · Engineer Foundations | Math → data stack → ML → deep learning → projects | ~9–12 months | Job-ready ML Engineer |
| 2 · Research Depth | Rigorous math → transformers & LLMs → reproducing papers | ~6–9 months | Research Engineer |
| 3 · Research Practice | Original experiments → writing → community | Ongoing | AI Researcher |
The timelines assume steady part-time study. More hours means faster. Fewer hours is fine too — the order matters far more than the speed.
The Four Rules That Make It Work
The structure is not the interesting part. The discipline is. These four rules are what separate this from every bookmark folder full of good intentions.
1. Strict order. No parallel learning. Start a step, finish it completely, then start the next. No studying calculus "on the side" while doing machine learning. Parallel tracks feel productive and quietly guarantee that nothing gets finished. One thing at a time, all the way through.
2. One concept, one resource. Never two courses for the same topic. The urge to collect three linear algebra courses "to be thorough" is procrastination wearing a smart disguise. Pick the one resource named for that step and use only it. Comparing resources is not learning.
3. A lesson is "done" only when you have been tested on it. Watching a video to the end is not completion. In my system, a step counts as done when I can pass a short test on it — easy, normal, and hard questions, solved on paper, scored, with the exact error named. Testing is the course. Passive watching produces the illusion of knowledge; being tested produces the real thing.
4. Publishing is optional — but recommended. Push what you build to GitHub and write it up. It is not required to learn, but it compounds: it becomes your portfolio, your proof of work, and later, your research signal. This is your choice, not a rule you can fail.
If you take nothing else from this post, take these four. The resources below are replaceable. The discipline is not.
Phase 1 — Engineer Foundations
Five stages, nine steps, in order. This phase ends with you being a genuinely job-ready ML engineer.
Stage 1 · Mathematics. The base everyone is tempted to skip and nobody can afford to. You need working intuition, not a PhD.
| Step | Concept | The one resource |
|---|---|---|
| 1 | Linear algebra — vectors, span, basis, matrix transforms, eigenvalues | 3Blue1Brown — Essence of Linear Algebra |
| 2 | Calculus — limits, derivatives, the chain rule (this is backpropagation) | 3Blue1Brown — Essence of Calculus |
| 3 | Multivariable basics — partial derivatives, the gradient (what gradient descent uses) | 3Blue1Brown gradient videos + worked practice |
| 4 | Probability & statistics — distributions, Bayes, random variables, mean & variance | StatQuest — Statistics Fundamentals |
You do not need all of these end to end. For linear algebra, the visual chapters that build intuition are what matter; the mechanical detours can wait. The point is to see what a matrix does and why a gradient points where it points — not to grind every identity.
Stage 2 · Data Analysis. The Python data stack: Jupyter, NumPy, Pandas, Matplotlib, and real exploratory data analysis, with small build projects along the way. Resource: freeCodeCamp — Data Analysis with Python. This is where I am right now, and it is the first stage that feels like doing rather than studying.
Stage 3 · Machine Learning. The classic core — regression, classification, decision trees, clustering, recommenders, and the practical habits that keep models honest. Resource: Coursera — Machine Learning Specialization (Andrew Ng), which you can audit for free.
Stage 4 · Deep Learning. The modern engine — deep networks, optimization, CNNs, and sequence models — followed by the single most important step in the whole phase: building a small GPT from scratch, in code, so the transformer stops being magic.
- Deep networks & the theory: Coursera — Deep Learning Specialization (Andrew Ng)
- ★ Build a mini-GPT by hand: Andrej Karpathy — Neural Networks: Zero to Hero
Stage 5 · Projects. Three builds, in increasing difficulty, each one shipped:
| Level | Project | What it proves |
|---|---|---|
| Beginner | House Price Prediction | Regression, data cleaning, features |
| Intermediate | Movie Recommendation System | Recommenders, filtering |
| Advanced | Mini-GPT, then fine-tune an open model | Transformers, training, evaluation |
One note on tooling: the courses teach in TensorFlow, which is fine — but your personal framework should be PyTorch, because it is the language most research is written in. Learn the concepts in whatever the course uses, then re-implement in PyTorch.
Finish this phase and you are a job-ready ML engineer. That alone is worth the climb.
Phase 2 — Research Depth
This is where you cross from using models to understanding the papers that create them. Start it only after Phase 1 is genuinely complete. Same system: one step, one resource, in order.
| Step | Concept | The one resource |
|---|---|---|
| 1 | Linear algebra, rigor pass — now you are ready for the real thing | MIT 18.06SC — Gilbert Strang |
| 2 | The math papers actually use — vector calculus, probability, optimization | Mathematics for Machine Learning (free book) |
| 3 | NLP & transformers — word vectors → attention → pretraining → LLMs | Stanford CS224n |
| 4 | Hands-on LLMs — tokenizers, datasets, fine-tuning, evaluation | Hugging Face — LLM Course |
| 5 | ★ Reproduce 3–5 papers — read, reimplement in PyTorch, match a number, write up what didn't | Papers with Code |
For the reproduction step, a suggested reading order that builds on itself: Attention Is All You Need → GPT-2 → BERT → Adam → LoRA. The goal is not to admire these papers — it is to rebuild them and see where your numbers diverge from theirs. That gap, and your honest write-up of it, is the beginning of research taste.
Finish these five steps and you operate like a research engineer.
Phase 3 — Research Practice
There is no course for this phase, because this phase is the work itself. It is ongoing, done in public, with a community.
The engine is a loop:
Reproduce → ablate (change one thing, measure the effect) → question → run a small original experiment → write it up → share → repeat.
Original research is that loop, run honestly, many times. It is less mysterious than it sounds and more demanding than it looks.
Find your unfair advantage — and use it. The fastest realistic route to a first publication is not competing with the entire planet on the same crowded benchmark. It is finding the corner of the field where you have an edge nobody else does. For me, that edge is being a native Somali speaker with health-domain experience and access to a real low-resource-language context. Somali is genuinely underserved in NLP, and low-resource-language research is an active frontier with open, welcoming communities — groups like Masakhane publish real, cited work from contributors without a PhD gate. Yours might be a language, an industry, a dataset, or a problem you understand from the inside. Whatever it is, it is your shortcut.
Open-source contributions, public paper notes, and benchmarks or evaluations posted on your blog all count as research signal too. You do not need permission to start contributing.
How to Actually Use This
A short set of reminders, because knowing the map is not walking it:
- Go in order. The sequence is the product. Skipping ahead is how people end up lost.
- One resource per step. Resist the collector's instinct. Finish, then move.
- Get tested, don't just watch. If you cannot solve a problem on paper, you have not learned it — you have seen it.
- Ship the optional write-ups anyway. Future-you job hunting, or submitting a first paper, will thank present-you.
- Measure your speed in finished steps, not hours logged. Completion is the only metric that compounds.
The common ways this fails are predictable: parallel learning that finishes nothing, tutorial loops that feel like progress but build nothing, skipping the math and hitting a ceiling later, and chasing every new tool instead of mastering the durable concepts underneath them. Every rule above exists to block one of those failure modes.
Where This Stands Today
This roadmap is not a finished artifact I am handing down — it is a live one I am building as I climb. The repository already contains the full mathematics foundation (linear algebra, calculus, multivariable basics, and probability & statistics) with notes and notebooks, and it is now growing into the data analysis stage. Every step gets committed as I complete it, so the commit history is the honest progress log.
If you have been standing at the start of this path, confused about which of a hundred roadmaps to trust, take this one and stop shopping. Follow it in order, one resource at a time, and let the finished steps stack up. Watch it grow, fork it, or just follow along:
Repository: https://github.com/asadlion11/AI-Research
Final Thoughts
Becoming an AI researcher is not a matter of talent or of finding the one perfect course. It is a matter of sequencing — doing the right things in the right order, finishing each before starting the next, and proving to yourself that you actually learned each step before you move on. The field is enormous and moves fast, but the foundations are stable and the path through them is walkable. One step at a time, one resource per step, strictly in order. That is the whole secret, and it is enough.
I will keep publishing each stage as I reach it. If this map saves even one person from tutorial hell, it will have earned its place.
Author: Mohamed Abdiaziz Aweis