Learn AI Without Quitting Your Job: 30 Min/Day Plan
You don't need to quit your job to break into AI. 30 minutes a day, compounding for 12 months, is enough to land an AI engineering role in 2026. This is the plan that actually works — built for working professionals who have $20K bootcamp money but $0 bootcamp time.
Anyone who tells you that you cannot learn AI while working a full-time job is usually selling a bootcamp. The arithmetic says otherwise: 30-45 minutes a day for twelve months is more total study time than most intensive programmes deliver, spread out in the way memory research says actually works. The bottleneck is not the hours available. It is what you do with them, every day, with the kind of discipline that compounds. This lesson is the operating manual.
Learning Objectives
After this lesson, you will be able to:
Design a sustainable 30-minute daily ML learning habit that survives real life (kids, deadlines, travel, illness)
Every 30-minute session has three parts. Do them in order. Do not skip any.
10 minutes — Read. One concept. One lesson page. One paper section. One blog post. You are not trying to finish anything — you are trying to load the concept into working memory.
15 minutes — Code or compute. Type the example into your editor. Run it. Break it deliberately. Print intermediate values. Change a hyperparameter and re-run. If the topic is non-coding (e.g., a math derivation), use this time to redo the derivation by hand on paper. The point is to make your hands do something. Reading without doing is the single biggest reason people study for a year and remember nothing.
5 minutes — Reflect and capture. Write one paragraph in a markdown file titled with today's date. What did I just learn? What is one example I would give to a 12-year-old? What is one question I still have? Add one Anki card if the concept is something you will need again.
That is it. Set a timer. Stop when it rings. If you skip the reflection step, the entire session is roughly 30% less effective at long-term retention — every learning-science meta-analysis since 2010 agrees on this.
Spaced repetition is the least glamorous and most reliably effective tool in self-directed study. You either adopt something like Anki early, or you spend a year rediscovering why it exists.
Anki is a free flashcard app that schedules cards based on an SM-2 spacing algorithm. New cards repeat after 1 day, then 3, then 7, then 21, then ~2 months, then ~6 months, then a year. Forgetting one resets the schedule. You spend 5-10 minutes a day reviewing.
Build the deck as you go. After each 30-minute session, add 1-3 cards from the reflection step. Examples:
Q: What is the formula for softmax of a vector x?
A: softmax(x_i) = exp(x_i) / sum_j(exp(x_j))
For stability, subtract max(x) before exponentiating.
Q: Why divide by sqrt(d_k) in scaled dot-product attention?
A: To keep the variance of QK^T at 1 regardless of d_k. Without it,
large d_k makes scores grow, softmax saturates, gradients vanish.
Q: When is L1 regularization preferred over L2?
A: When you want sparsity (feature selection). L1 drives weights to
exactly zero; L2 only shrinks them.
Rules
One concept per card. If a card has two facts, split it.
Test recall, not recognition. Question side asks "what is X?" Answer side has the answer.
Use cloze deletion for formulas: "Bayes rule: P(A|B) = P(B|A) · P(A) / __" — fill in the blank.
Suspend cards you keep failing. Look up the concept again. Re-add the card with a clearer question.
After 6 months of disciplined Anki, you will have 400-600 cards covering everything from softmax to attention to k-means initialization to the SQL window-function syntax. That deck is the single highest-leverage artifact you build as a self-taught ML engineer.
The 30-minute habit is for weekdays. Don't push it on the weekend.
Weekends are for deep dives: 2-4 hour blocks where you sit down and actually build something. The weekday habit feeds the weekend dive: by Saturday you have read 5 concept pages and written 5 small code snippets. The Saturday deep dive is when you wire them together into one project.
A good weekend pattern:
Saturday morning (2-3 hours): Project work. Build something. Wire pieces from the week into one running thing.
Saturday afternoon: Off.
Sunday morning (1 hour): Review the week's notes. Adjust next week's roadmap. Push a commit and a README update.
Sunday afternoon: Off.
The off time is non-negotiable. If you cannot give yourself one full afternoon off the topic every weekend, you are on the road to burnout — and burnout is measured in months of recovery, not weeks.
The signs that you are heading for burnout, in order of appearance:
Week 4-6: You start skipping the reflection step. "I'll just read one more thing." Output stops compounding.
Week 6-8: You start treating the timer as a finish line. You stop when it rings, even mid-thought. Engagement dropping.
Week 8-10: You skip a day. Then two. Then you tell yourself "I'll make it up on Saturday." You won't.
Week 10-12: You stop entirely. You feel guilty about the unfinished course. You declare "I just don't have time for this."
The mitigation is built into the system. If you notice you are at stage 1, shrink the session, do not skip it. A 10-minute session today is infinitely better than a planned 30-minute session that you bail on. Anki for 5 minutes counts. Reading one paragraph counts. The habit is what matters; the duration on any individual day does not.
Skipping is the killer. Once you have skipped a day, the second skip is 5x more likely than the first. The third skip is 10x more likely than the second. After three skips in a row, you are functionally restarting from zero. Whatever it takes — open the editor, type one line, close it — keep the streak alive.
For someone who has never written ML code before. Adjust the topics to your starting level, but keep the structure.
Week 1 — Python and tooling for ML
Day 1 (Mon): Set up Python 3.11, VS Code, a git repo for daily notes. Write the world's smallest neural network in 20 lines using only math.exp and a Python list.
Day 2: NumPy basics. Vector ops, broadcasting. Reproduce yesterday's neural net in NumPy.
Day 3: pandas basics. Read a CSV, group, aggregate, plot one chart with matplotlib.
Day 4: Jupyter / VS Code interactive notebooks. The %matplotlib inline trick. Inline DataFrame display.
Day 5: Anki: add 10 cards from this week (NumPy axis convention, pandas DataFrame vs Series, broadcasting rules).
Weekend deep dive: download the UCI Iris dataset. Load it, explore it, plot pairwise scatter. No ML yet.
Week 2 — Your first model
Day 6: scikit-learn intro. Train/test split. Logistic regression on Iris. Check accuracy.
Day 7: Read about precision, recall, F1. Compute all three for Iris.
Day 8: Decision trees. Train one on Iris. Plot the tree.
Day 9: Random forest. Compare to a single tree. Talk about variance reduction in your reflection note.
Day 10: Cross-validation. Run 5-fold CV on Iris. Compare CV score to single-split score.
Weekend: Repeat the whole pipeline on a second dataset (Wine or Breast Cancer from sklearn.datasets). Note what is similar and what is different.
Week 3 — Generalization and feature engineering
Day 11: Overfitting. Train a deep decision tree, see train acc = 100% and test acc much lower. Diagnose.
Day 12: Regularization (L1, L2). Try both on logistic regression with a high-dimensional dataset.
Day 13: Feature scaling. Compare logistic regression with and without StandardScaler on a dataset where it matters.
Day 14: Feature engineering: one-hot encoding, ordinal encoding, when to use each.
Day 15: Pipelines. sklearn.pipeline.Pipeline so your preprocessing and modeling stay in sync between train and test.
Weekend: Pick a Kaggle "Getting Started" competition (Titanic). Submit something. Even a bad submission. Lock in the submission workflow now, not when stakes are higher.
Week 4 — First deep learning
Day 16: PyTorch tensors. Move yesterday's NumPy code to torch. Note the device handling.
Day 17: Autograd. Compute a gradient by hand and verify with loss.backward().
Day 18: A 2-layer MLP on MNIST. Use a Kaggle notebook with free GPU.
Day 19: Training loop anatomy: zero_grad, forward, loss, backward, step. Print loss every 100 batches.
Day 20: TensorBoard or simple matplotlib loss curves. Verify your model is actually learning.
Weekend: Push your week 4 model to GitHub. Write a 200-word README. Post the link in a learning Discord. The visibility step matters more than the code.
End of Month 1. You now have: NumPy/pandas fluency, sklearn fluency, one trained PyTorch model on MNIST, a GitHub repo with 4 weeks of daily notes, and an Anki deck with ~40 cards. This is more than 95% of people who "have been meaning to learn AI" have ever done.
Monthly review: sit down on day 30 with the journal. What stuck? What was wasted time? What is the one topic to spend month 2 on?
This site's RAG and ML Engineering tracks (8 and 10).
Months 10-12 (Specialization + portfolio)
Pick one domain. Read 1 recent paper per week. Reimplement key pieces.
Build one substantial portfolio project (see the Portfolio Guide lesson).
Start interviewing — even rejection interviews count as study sessions.
#A Real Example: Maya, Zero to Junior ML Engineer in 12 Months
Maya was a backend engineer at a logistics company. She joined a study group I ran in early 2023. Her stack was Java/Spring. She had not done linear algebra since university and could not write a NumPy slice from memory.
Her habit: 30 minutes every weekday morning, 6:30-7:00 AM, before her kids woke up. Saturday morning 2 hours. Sundays off. No exceptions for travel — she did sessions on planes and trains. Total time invested over 12 months: roughly 160 hours of weekday habit + 90 hours of weekend dives = 250 hours. About one university semester's worth.
Months 1-3: NumPy, pandas, sklearn. Built a customer-churn model on her company's anonymized data as a side project (approved by her manager). Pushed to GitHub.
Months 4-6: PyTorch + MNIST + Karpathy's makemore series. Built a small character-level RNN that generated fake project names for her company. Posted on LinkedIn. Got 600 reactions, two recruiter DMs.
Months 7-9: RAG. Read every Anthropic and OpenAI cookbook. Built a RAG bot over her team's Confluence pages and demoed it at an internal hackathon. Won. Got moved into a 50% ML role at the same company.
Months 10-12: Started interviewing externally. Failed her first 4 (CodeSignal-style coding rounds were brutal coming from Spring backend). Studied LeetCode for 20 min/day, kept the ML 30 min/day. Passed her 5th and 6th. Got two offers, took an applied-ML role at a mid-stage healthtech startup. 25% comp bump.
Maya's actual journal entry from day 1: "Wrote a Python neural network using only math.exp and a list. It overfits one example. I am tired. Tomorrow: NumPy."
Her actual journal entry from day 365: "Signed offer letter. Resigning from logistics-co tomorrow. Anki deck now has 612 cards. Built 9 GitHub repos this year. Could not have done it in less than 12 months. Could not have done it in more, either — kids start school in three weeks."
The pattern is not unusual. It is what consistent, repeatable, daily 30-minute practice produces.
The first Sunday of every month, sit with your journal and answer:
markdown
# Monthly Review — Month N
## Streak stats
- Sessions done this month: ___ / 22 weekdays
- Weekend dives completed: ___ / 4
- Anki cards added: ___
- Anki cards retired (mastered, removed): ___
## What I learned (top 5 concepts)
1. ___
2. ___
3. ___
4. ___
5. ___
## What I built
- [ ] ___
- [ ] ___
## What did not stick
- Concepts I cannot explain to a colleague: ___
- Skills I have not used in 2+ weeks: ___
## Course corrections for next month
- Drop: ___
- Add: ___
- Double down on: ___
## One sentence summary
___
Doing this monthly is 30 minutes well spent. It catches drift early (you have spent 4 weeks on transformers and still cannot code a basic training loop) and reanchors your roadmap when life inevitably nudges it sideways.
You are between jobs and have the bandwidth (just don't do 4 hours in one go — diminishing returns hit hard after about 90 minutes of concentrated study).
You are within 3 months of a target interview and need to push.
Your day job is light and you genuinely have the time.
Slow it down to 15 min/day if
Newborn at home.
Major work crunch (launch, on-call, layoff stress).
You are sick or recovering from illness.
15 min/day still keeps the habit alive. 0 min/day kills it. The whole point of this system is that the habit survives the bad months.
Pause cleanly (planned break) if
Vacation longer than 1 week.
Surgical recovery, family emergency, anything serious.
Plan the restart date in advance. Write it in your journal: "Restarting 2026-08-01." The planned pause is fundamentally different from the accidental skip. The former is a normal part of a multi-year habit. The latter is the failure mode.
The Effects of Distributed Practice on the Acquisition and Retention of Knowledge
John Dunlosky, Katherine Rawson, Elizabeth Marsh, Mitchell Nathan, Daniel Willingham (2013)
Meta-analysis published in Psychological Science in the Public Interest. Across hundreds of studies, distributed practice is the single most effective study technique, beating re-reading by 2-3x in long-term retention. The 30-min-daily approach is operationalized distributed practice.
You did your 30-minute session on Monday, Tuesday, and Wednesday. Thursday is brutal at work and you have 8 minutes available. What is the correct action?
30 min/day × 5 days × 52 weeks = 130 hours/year — one university course per year, every year, indefinitely. Sustainable pace beats sprints.
Use the 10/15/5 micro-structure: read, code, reflect. Skip any of the three and retention drops 30%+.
Spaced repetition with Anki is non-negotiable for long-term retention. Add 1-3 cards per session; 5-10 minutes of daily review.
Weekdays for habit, weekends for depth, Sundays for review. One full day off every week is not optional.
Keep the streak alive even on bad days. 5 minutes today beats a planned 30 minutes you bail on. Skipping is the killer.
Monthly reviews catch drift. 60 minutes on the first Sunday of every month saves you 4 weeks of wasted study.
Tomorrow morning, do 30 minutes. Not 31. Not 25. Add one Anki card. Open the editor, write one paragraph of reflection, close the editor. Then do it again the next day. That is the entire system.