Software Developer → ML / Applied AI Engineer

Overall strategy

Do not restart your career. Build on your software engineering experience and add ML, PyTorch, modern AI application development, and production ML skills.

8–10 hrs/weekKeep current jobBuild while learning3 serious projects3 buffer weeks~340 hrs — ~290 learning + ~50 job search

Stage 0 — Set yourself up

Duration: Week 0

The goal is to make sure you can spend the next several months building without environment problems slowing you down — and to gather the two pieces of information you will need much later, while gathering them is still cheap.

This week is full: nine hours covers the market scan, the installs, the compute decision, and the book mapping. If installs go badly, the scan and the mapping are the parts to protect. Everything else here can be finished in Week 1.

Scan your actual market first

Ninety minutes, before you install anything. Pull 20 real job postings from the market you can actually work in — your city, your country, or remote roles that hire from it — across the titles listed in Stage 6. For each, note the title, the modelling depth asked for, whether cloud, Kubernetes, or an orchestrator appears, and whether they want RAG and evaluation or classical ML.

You are not choosing your specialism today. The Applied AI and MLE tracks in this plan are nearly identical until Week 22, so committing now would mean deciding with the least information you will ever have. You are building the evidence for the decision in Week 16, once you have shipped Project #1 and know what you actually enjoy. Save the file; you will re-read it then.

Install and configure

Skip what you can already prove

You are an experienced software developer, and parts of this plan are written for someone who is not. Do not sit through them out of diligence. Each skip is earned by producing an artifact this week — not by feeling confident about it.

Bank every hour you save. It goes to Week 22 (attention), Week 27 (retrieval quality), or Project #3 — the three tightest points in the plan. It does not go to finishing early.

Decide your compute and cost plan now

Week 21 fine-tunes a pretrained vision model and Stage 4 calls paid LLM APIs. Both fail late and expensively if you have not decided where they run. Settle this in Week 0, not in Week 21.

Map the book to the schedule

Twenty minutes, this week. Open your copy of Géron, and write the chapter numbers next to the week table in this plan. Two things fall out of that exercise:

• You confirm which edition you actually have, which determines whether Stage 3 works as written (see the edition warning above).
• You find the weeks with no chapter behind them — Weeks 5, 12, 13, and all of Stages 4 and 5 are not in the book at all. Those need other sources, and it is better to know that now than to go looking mid-week.

Name a source for every orphaned week before this week ends. Discovering in Week 28 that you have no material is the same failure as discovering in Week 21 that you have no GPU — it just arrives later and costs more. Write one primary resource next to each of Weeks 5, 12, 13, and 26–32. The durable, first-party places to start:

• PyTorch (Weeks 17–24) — the official tutorials and docs, essential if your Géron edition turns out to be the TensorFlow one.
• FastAPI and Docker (Weeks 12, 36) — both have first-party documentation good enough to learn from directly.
• Experiment tracking (Week 13) — MLflow's own quickstart, or the equivalent for whichever tool you pick.
• LLM APIs, embeddings, tool calling, prompt injection (Weeks 26–30) — your chosen provider's documentation. On models, pricing, and safety guidance it is the only source that stays current.

Deliberately not pre-filled here: a chapter map for an edition you may not own, and deep links that rot within a year. Both would be confidently wrong, which is worse than absent.

Pre-write your cut-list

Three buffer weeks across 38 is roughly 8% slack — thin for eight months alongside a full-time job. The buffers will absorb a bad fortnight; they will not absorb a bad quarter. So decide now, while you are rested and nothing has gone wrong, what gets sacrificed when something does.

The rule: if you reach a buffer week already behind, cut from this list rather than extend the schedule. In order:

1. Week 11 clustering — read for awareness, build nothing.
2. Week 3 confidence intervals and sampling theory — know the vocabulary, move on.
3. Week 9 tree internals — Gini versus entropy is not worth a week of slippage.
4. Week 21 computer vision — only once you have committed to the text path for Project #2.
5. Project #2 collapsed from two weeks to one — last resort, and it costs you the error analysis.

Nothing in Stages 4 or 5 appears on this list. Those weeks are the portfolio.

Suggested learning repository

ml-transition/
├── python/
├── numpy/
├── pandas/
├── sql/
├── math/
├── sklearn/
├── pytorch/
├── notebooks/
└── projects/

Stage 1 — Foundations

Duration: Weeks 1–4

Do not spend months preparing before touching ML. Four focused weeks are enough to start.

Week 1 — Python for data work

Review lists, dicts, sets, tuples, comprehensions, functions, lambdas, classes, exceptions, context managers, iterators, modules, packages, and type hints.

Your target is not clever Python. Your target is being able to read ML code without the language itself slowing you down.

Week 2 — NumPy + Pandas + SQL

Practice on a CSV dataset. Explore missing values, distributions, correlations, outliers, and target balance before training any model. Then load the same dataset into a database and reproduce three of those analyses in SQL.

Week 3 — Statistics

Learn mean, median, variance, standard deviation, percentiles, correlation, probability, conditional probability, independence, random variables, normal distributions, expected value, sampling, population vs sample, bias, variance, confidence intervals, and noise.

Week 4 — Linear algebra + calculus

Focus on scalar, vector, matrix, tensor, vector addition, dot product, matrix multiplication, transpose, dimensions, functions, slope, derivative, partial derivative, gradient, and chain-rule intuition.

prediction
   ↓
calculate loss
   ↓
calculate gradient
   ↓
adjust parameters
   ↓
repeat

Stage 1 mini-project

load data
↓
clean data
↓
basic statistics
↓
plots
↓
written conclusions

Stage 1.5 — Early win: ship a small AI demo

Duration: Week 5

This week is out of sequence on purpose, and it is the most important structural change in the plan.

Your leverage as a working software engineer is application engineering, not model research. That skill needs no ML theory at all — you can call an LLM API and wire up retrieval with the Python you already have. Building it now, before you have "earned" it, gives you three things you would otherwise not have until Month 8:

• Something concrete to show and talk about, months before the flagship project exists.
• A real reason to care about the abstract material in Stages 2 and 3 — you will have already felt the problems that evaluation and retrieval quality solve.
• Proof to yourself that the transition is achievable, at the point in the roadmap where motivation is most fragile.

Scope it aggressively

Nine hours — the whole week, not one weekend. Your routine gives you five hours across Saturday and Sunday; the other four come from the weekday slots, spent reading provider documentation so the weekend is pure building. Load a folder of documents, chunk them naively, embed them, store them in the simplest vector store you can find, and answer questions over them from a command line. No auth, no database, no UI, no tests, no Docker.

your documents
   ↓
naive chunking
   ↓
embeddings
   ↓
simple vector store
   ↓
question → retrieve → LLM → answer

It will be mediocre. That is the point — Weeks 27 and 30 exist to teach you exactly why, and in Week 27 you will fork this repository into Project #3 and rebuild it properly.

Stage 2 — Classical Machine Learning

Duration: Weeks 6–16

This is the core Scikit-Learn stage and the first major section of Géron’s book.

Week 6 — ML landscape + end-to-end workflow

Study supervised vs unsupervised learning, batch vs online learning, overfitting, underfitting, generalization, hyperparameters, validation, and test sets.

Problem
 ↓
Data
 ↓
Quick structural look — shape, dtypes, target balance
 ↓
Choose split strategy → reserve the test set
 ↓
Detailed EDA — training data only
 ↓
Preprocessing
 ↓
Baseline
 ↓
Train models
 ↓
Cross-validation
 ↓
Tune
 ↓
Evaluate on the test set — once
 ↓
Deploy
 ↓
Monitor

Week 7 — Classification

Learn binary and multiclass classification, confusion matrices, accuracy, precision, recall, F1, ROC, AUC, PR-AUC, calibration, and decision thresholds.

Change the decision threshold on a small classifier and observe what happens to precision, recall, and F1.

Week 8 — How models learn

Study linear regression, gradient descent, SGD, polynomial regression, regularization, Ridge, Lasso, Logistic Regression, and learning curves.

Implement a tiny linear regression model once without Scikit-Learn to understand prediction, loss, and optimization.

Week 9 — Decision Trees

Study splits, Gini impurity, entropy, depth, overfitting, and regularization. Train trees with different maximum depths and visualize the behavior.

Week 10 — Ensembles

Learn bagging, Random Forests, Extra Trees, AdaBoost, Gradient Boosting, Histogram Gradient Boosting, stacking, and feature importance.

Compare Logistic Regression, Decision Tree, Random Forest, and Gradient Boosting on the same problem.

Week 11 — Dimensionality reduction + clustering

Learn PCA, the curse of dimensionality, and K-Means. These two carry almost all of the interview and practical weight in this area.

Week 12 — Serving: FastAPI + Docker

Moved forward from Stage 5, because Project #1 requires it. Wrap a trained Scikit-Learn model in a FastAPI endpoint with a request/response schema, containerize it, and run the container locally. Keep it minimal — no auth, no database.

Week 13 — Experiment tracking

Track model versions, dataset versions, hyperparameters, metrics, artifacts, and code versions. Use a tool such as MLflow or an equivalent. You want this habit in place before Project #1, not after, so the project produces a real experiment log instead of a folder of forgotten notebook runs.

Weeks 14–15 — Project #1

Choose a structured-data problem such as customer churn, loan default, employee attrition, fraud detection, house prices, insurance claims, or customer conversion.

Mandatory, in this order: data loaded and split, baseline recorded, one trained model that beats it, honest evaluation on the held-out set exactly once, the FastAPI endpoint from Week 12, a Dockerfile, a README. Stretch, and only once all of that runs: comparison across four algorithms, hyperparameter tuning, feature-importance analysis, calibration plots. A finished small project beats an unfinished thorough one, and the Week 16 buffer is not a licence to start stretch goals in Week 15.

project/
├── data/
├── notebooks/
│   └── exploration.ipynb
├── src/
│   ├── preprocessing.py
│   ├── train.py
│   ├── evaluate.py
│   └── predict.py
├── tests/
├── models/
├── api/
│   └── main.py
├── Dockerfile
├── requirements.txt
└── README.md

Your README should explain the problem, dataset, metric choice, experiments, final result, failure modes, and how to run/deploy the project.

Stage 3 — Deep Learning + PyTorch

Duration: Weeks 17–25

Week 17 — Neural network fundamentals

Learn neurons, layers, inputs, weights, biases, activation functions, forward pass, loss, backpropagation, epochs, batch size, and learning rate.

Week 18 — PyTorch fundamentals

Learn tensors, nn.Module, autograd, Dataset/DataLoader, model saving/loading, and basic optimization.

for X, y in loader:
    optimizer.zero_grad()
    prediction = model(X)
    loss = criterion(prediction, y)
    loss.backward()
    optimizer.step()

Week 19 — Build small neural networks yourself

Implement a regression neural network, a binary classifier, and a multiclass classifier. Track training loss, validation loss, and useful metrics.

Week 20 — Training deep networks

Study vanishing gradients, initialization, ReLU, normalization, gradient clipping, Adam/AdamW, learning-rate scheduling, dropout, weight decay, and transfer learning.

Week 21 — Computer vision

Learn CNNs, convolution, kernels/filters, pooling, feature maps, ResNet, and transfer learning. Fine-tune a pretrained vision model on a small dataset — this is the week your Week 0 GPU decision pays off.

If you chose Applied AI in Week 16, this is the first week to trade away. Skim it for vocabulary, take the text path in Weeks 23–24 where you will fine-tune a transformer instead, and move the recovered hours to Week 22 or Week 27. If you chose MLE, keep it in full.

Week 22 — Attention + Transformers

Go deep on (about 6 hours): tokenization, embeddings, attention, and Transformer architecture. Attention is the one idea in this week that interviewers actually probe, and it is the foundation of everything in Stage 4.

Working familiarity only (about 3 hours): load and run a pretrained model through Hugging Face, and know the BERT vs GPT-style distinction, in-context learning, and instruction tuning well enough to hold a conversation. You will use all of these constantly in Stage 4 without needing to have trained one.

Weeks 23–24 — Project #2

Two weeks, not one. Build either an image classifier or text classifier with PyTorch. Include a Dataset/DataLoader, training loop, evaluation, experiment tracking, inference API, and an error-analysis section.

As with Project #1, choose the dataset and the target metric in Week 22 rather than Week 23, and separate mandatory from stretch: a working training loop, honest evaluation, and the error analysis are mandatory; architecture comparisons and hyperparameter sweeps are not. The same reproducibility rules apply — one command, pinned versions, fixed seeds, data provenance, stated limitations.

If you choose the text path, fine-tune a small pretrained transformer rather than training from scratch — this is the fine-tuning exercise deferred from Week 22, and it belongs here where the hours exist.

The error analysis is the part that distinguishes you from a tutorial follower. Look at the examples your model gets wrong, categorize the failures, and write down what you would do next. Interviewers ask about this.

Stage 4 — Applied AI / LLM Engineering

Duration: Weeks 26–30

You built a naive version of this in Week 5. Now you learn why it was mediocre. From this week onward the job search runs in parallel — see Stage 6 for how the hours split.

Week 26 — LLM APIs

Learn system/user messages, context windows, tokens, temperature, structured outputs, streaming, rate limits, retries, timeouts, caching, and cost modelling.

Caching earns a mention of its own because it decides whether the evaluation suite you are about to build is something you can afford to run on every commit or something you run twice and quietly abandon. Work out the per-run cost of that suite now, and know which lever brings it down — prompt caching, response caching, or a smaller model for iteration.

Week 27 — Embeddings + vector search

Learn embeddings, vector similarity, cosine similarity, semantic search, chunking strategies, vector storage, and reranking.

Reranking is the cheapest large win available in retrieval, and it sits on the Stage 6 interview list, so it belongs here rather than nowhere: retrieve generously with vector search, then reorder the candidates with a stronger cross-encoder or model-based scorer before anything reaches the LLM. Measure the difference — it doubles as the clearest proof that your evaluation set actually works.

Project #3 starts this week. Fork your tagged v0 demo into a new repository and leave v0 untouched. Everything below lands in the fork.

Week 28 — RAG

Assemble the full pipeline in the Project #3 repository, running the development set as you go. Answer quality now rests on retrieval quality, and you already have numbers for the second.

Documents
   ↓
Parser
   ↓
Chunks
   ↓
Embeddings
   ↓
Vector DB

User question
   ↓
Embed question
   ↓
Retrieve chunks
   ↓
LLM
   ↓
Answer + sources

Week 29 — Tool calling, and the failure modes that matter

Learn tool/function calling, workflow state, retries, tool failures, timeouts, structured-output failures, and human approval boundaries.

Weight this week toward security and failure handling rather than agent frameworks. Spend roughly half of it on prompt injection, untrusted retrieved content, and data leakage. That is not a detour: your system reads documents and hands them to a model that can call tools, so a hostile instruction hidden in a retrieved chunk is precisely the shape of the threat. "What happens if one of your documents tells the assistant to ignore its instructions?" is a question an interviewer can ask about the system you actually built. Generic multi-agent orchestration is not.

Week 30 — Evaluation

Expand the Week 27 development set into a real evaluation suite: add expected answers alongside the expected sources, cover the failure cases you have hit since, and add cases that exercise both the tool and the injection attempts from Week 29. Track Recall@k and MRR for retrieval, citation correctness (do the cited sources actually support the answer?), faithfulness and hallucination rate, task success, tool success, latency, and cost per query.

Make it runnable as a single command that prints a table of scores. That command is what turns Project #3 from a demo into something you can defend in an interview — and it is what Week 31's CI will run.

Stage 5 — Production ML + flagship project

Duration: Weeks 31–37

Production skills come before the hardening weeks, so Project #3 can actually apply them instead of promising them. The system itself already exists — you have been building it since Week 27.

Week 31 — CI/CD + ML testing

Test data schemas, preprocessing, model loading, prediction shapes, feature ranges, API behavior, and evaluation regressions. Add CI to GitHub, and retrofit it onto Projects #1 and #2 while the material is fresh.

For Project #3, CI runs your Week 30 evaluation command on every push and fails the build when a metric regresses past a threshold you set. That one check is the most persuasive thing in the repository: it says you treat retrieval quality as something that can break, rather than something you measured once and hoped about.

Week 32 — Monitoring + drift

Learn service health, latency, error rates, data drift, prediction drift, model degradation, LLM evaluation regressions, and cost monitoring.

Weeks 33–36 — Project #3, hardening the flagship

Four weeks at the reduced Stage 6 rate of 5 hrs/week — about 20 hours, not the 36 an uninterrupted schedule would give you. The job search peaks in exactly these weeks and takes priority.

Twenty hours does not build a production RAG system. It comfortably hardens one that has existed since Week 27, has been measured since Week 27, and already carries an evaluation suite, one tool, and CI. That is the entire reason Stage 4 committed its work to this repository — do not restart here. Your target:

Documents
   ↓
Parsing / chunking
   ↓
Embeddings
   ↓
Vector database
   ↓
Retrieval + reranking  ←── measured against your eval set
   ↓
LLM  ⇄  filtered-retrieval tool
   ↓
API (answer + sources)
   ↓
Logging + eval suite in CI

Ship at the end of each week. A working narrow system in Week 33 that grows is far better than an ambitious system still broken in Week 36.

Stage 6 — Interview + job transition

Start: Week 26. Runs in parallel for the remaining twelve weeks. Do not wait until the roadmap is complete.

Weekly job-search activities from Week 26

Roles this roadmap trains you for

Apply to these from Week 26, leading with the primary role you chose in Week 16 and the fallback alongside it. Your portfolio speaks directly to what they interview on, and your existing software engineering experience is the differentiator rather than the thing you are apologising for.

Adjacent roles — reachable, but not fully covered here

Apply to these too; just know what you are missing so a gap does not surprise you in a screen.

ML interview topics

Bias vs variance, overfitting, regularization, data leakage, cross-validation, feature engineering, class imbalance, model selection, and evaluation metrics.

Algorithm knowledge

Linear Regression, Logistic Regression, Decision Trees, Random Forests, Gradient Boosting, K-Means, PCA, and Neural Networks.

Deep-learning knowledge

Gradient descent, backpropagation, activation functions, loss functions, batch size, learning rate, Adam, dropout, normalization, embeddings, attention, transformers, and fine-tuning.

AI-engineering knowledge

RAG, embeddings, vector search, chunking, reranking, tool calling, agents/workflows, structured outputs, evaluation, hallucinations, latency, cost, caching, and prompt injection.

Keep your software skills strong

Continue practicing data structures, algorithms, databases, APIs, distributed systems, system design, testing, Docker, cloud, Git, and CI/CD. This is your existing advantage — do not let it decay while you chase the new material.

Your three-project portfolio

Project #1 — Classical ML Weeks 14–15

Demonstrates Scikit-Learn, EDA, feature engineering, cross-validation, model comparison, metric choice under class imbalance, calibration, pipelines, API design, and Docker.

The only one of the three left running at a public URL — it holds no API keys and costs nothing per request, so it is the one that is safe to expose.

Project #2 — Deep Learning Weeks 23–24

Demonstrates PyTorch, Dataset/DataLoader, training loops, transfer learning, evaluation, experiment tracking, error analysis, and inference deployment.

Project #3 — Applied AI Weeks 27–36

Your flagship, and the one that gets the most calendar rather than the least. Demonstrates LLMs, RAG, embeddings, vector databases, reranking, one tool with failure tests, FastAPI, Docker, a runnable evaluation suite with a held-out set, monitoring, tests, and CI/CD.

Built across ten weeks rather than four: Weeks 27–30 produce it while you learn, Weeks 31–32 supply the production skills, and Weeks 33–36 harden it inside the ~20 hours the job search leaves. Auth, a UI, caching, and a separate application database are cut. The measured evaluation suite is what makes the project persuasive — protect those hours ahead of everything else.

Weekly routine

Weeks 0–25 — learning phase

Roughly 4 hours learning + 5 hours building each week. From Week 20 to Week 24, one weekday hour goes to CV and profile work instead.

Weeks 26–37 — learning + job search

Total stays around 9 hours. The mix changes; the load does not increase.

How to use AI while learning

You attempt it
   ↓
get stuck
   ↓
ask AI
   ↓
understand answer
   ↓
implement
   ↓
modify it yourself

Progress checkpoints

Every checkpoint has an externally verifiable artifact. "I feel like I understand it" is not a checkpoint — at 11pm on a Sunday you will always feel like you understand it.