Portfolio Timeline¶

Month-by-month view of what gets built, when it ships, and how to keep the whole ladder standing.

The portfolio is not built in Month 13 — it is built continuously across the roadmap, with each rung landing in the month its foundational learning phase completes. The timeline below maps every rung to a specific month, identifies dependencies between rungs, and includes maintenance checkpoints to ensure early rungs don’t decay while later ones are being built. A rotting GitHub repo from Month 2 that breaks by Month 10 tells a worse story than a portfolio that was never started.

Master Timeline Table¶

Month	Rung	Primary Deliverable	Platform	Status Tracker
2	Rung 1	PCA + Optimizers from NumPy scratch	GitHub	☐ Not started
4	Rung 2	Kaggle competition entry + post-mortem	Kaggle + Blog	☐ Not started
6	Rung 3	Neural network from scratch (chosen path)	GitHub	☐ Not started
8	Rung 4	Transformer lab + HuggingFace model card + blog post	GitHub + HuggingFace + Blog	☐ Not started
10	Rung 5 ⚠️ GATE	QLoRA fine-tune + RAG system + live deployment	HuggingFace Spaces + GitHub	☐ Not started
12	Rung 6 ⚠️ GATE	Production ML pipeline (live, monitored)	Live endpoint + GitHub	☐ Not started
13	Rung 7	Independent paper reproduction + analysis	GitHub + Blog	☐ Not started
13	Rung 8	3–5 technical blog posts (writing starts Month 4)	Substack / Medium	☐ In progress

Replace ☐ with ✅ when the acceptance criteria in the rung’s spec file are fully met — not when you think they’re done.

Month-by-Month Breakdown¶

Month 1 — Setup and Baseline¶

No portfolio deliverable. Use this month to:

Create and configure all platform accounts: GitHub (professional username), HuggingFace, Kaggle, Substack/Medium
Set up your GitHub profile README (placeholder version — update it as rungs complete)
Configure development environment: Python 3.11+, conda or venv, VS Code or preferred editor
Install base stack: NumPy, Matplotlib, pytest, scikit-learn, PyTorch, Jupyter
Read 2 existing portfolio READMEs from practitioners you respect. Note what makes them good.

End of month check: All accounts created. GitHub profile README published (placeholder). Local environment running.

Month 2 — Rung 1 Ships¶

Active build: Rung 1 (Math From Scratch)

Weeks 1–2: PCA implementation + visualization + MATH_NOTES Weeks 3–4: Optimizer implementations + tests + README + polish

End of month check: pytest tests/ passes. README displays correctly on GitHub. Pre-generated figures in figures/ directory. MATH_NOTES.md complete. GitHub profile README updated with Rung 1 link.

Time budget: ~27–34 hours across 9–11 sessions of 3 hours each.

Month 3 — Phase 1 Preparation + Rung 1 Polish¶

No new rung. Use this month to:

Select the Kaggle competition you’ll enter in Month 4 (identify current Playground Series season)
Run a dry EDA on the competition dataset to understand the data before the sprint starts
Refine Rung 1 README based on any feedback received
Write first LinkedIn post announcing Rung 1 (technical framing, not celebration)

Month 4 — Rung 2 Ships + Writing Begins¶

Active build: Rung 2 (Classical ML Battle)

Weeks 1–2: EDA + feature engineering + model baselines Weeks 3–4: Ensemble + Optuna tuning + submission + post-mortem writing

End of month check: Kaggle submission made. Public leaderboard score recorded. Post-mortem published (Kaggle notebook + blog). GitHub README updated.

Writing milestone: Post-mortem counts as Blog Post #1 toward Rung 8. Publish it.

Month 5 — Phase 2 Preparation¶

No new rung. Use this month to:

Choose which path for Rung 3 (micrograd extension / makemore / CNN from scratch)
Read Karpathy’s micrograd repo and makemore series without implementing anything yet (understand before building)
Do a first-pass read of the backpropagation chapter in your Phase 2 study materials
Run a simple 2-layer network in PyTorch and trace every operation manually with torch.autograd

Month 6 — Rung 3 Ships¶

Active build: Rung 3 (Deep Learning From Scratch)

Weeks 1–2: Layer implementations (forward passes) + initial training attempt Weeks 3–4: Backward pass debugging + gradient verification + MATH_NOTES + README

End of month check: pytest tests/test_gradient_correctness.py passes. Model converges (clear loss curve). MATH_NOTES complete. No notebooks as primary deliverable.

Warning: Month 6 is when most people discover their backward pass has a sign error or a transposition bug. Budget time for this. It is not a failure — it is the point of the exercise.

Month 7 — Phase 3 Preparation + Rung 2/3 Maintenance¶

No new rung. Use this month to:

Choose Rung 4 path (nanoGPT-style or fine-tuning path + specific domain task if fine-tuning)
Set up Rung 4 compute environment: verify Kaggle GPU allocation or Colab Pro subscription
Run a quick maintenance check on Rungs 1–3: do they still install cleanly? Are the requirements.txt accurate? Fix any bit-rot.

Maintenance check cadence: Review early rungs every 3 months to ensure they still run.

Month 8 — Rung 4 Ships¶

Active build: Rung 4 (Transformer Lab)

Weeks 1–2: Core implementation (Path A) or fine-tuning setup and domain task (Path B) Weeks 3–4: Training runs + ablation experiment + model card + blog post

End of month check: Model card live on HuggingFace Hub. Blog post published. GitHub README links to both. Training curve committed. Ablation documented.

Writing milestone: Transformer findings blog post counts as Blog Post #2 toward Rung 8. Publish it.

Month 9 — Phase 4 Preparation (Critical Prep Month)¶

This month determines whether Rung 5 ships on time.

No new rung, but high-leverage preparation:

Select the domain for QLoRA fine-tuning (see Rung 5 spec for options)
Source and curate the training dataset: clean, format, and split (train/val/test)
Source and process the RAG corpus: ≥ 500 documents, chunked and embedded
Run a test fine-tuning pass on a tiny model (GPT-2 or similar) to verify your setup works before Month 10
Create the RAGAS evaluation test set (50 Q&A pairs) now — this is time-consuming and must be done before training

Month 9 success criterion: At Month 10 Day 1, you have: clean dataset, processed corpus, verified training setup, and evaluation test set. You are not starting from zero.

Month 10 — Rung 5 Ships ⚠️ HARD GATE #1¶

Active build: Rung 5 (LLM Engineering)

Weeks 1–2: Fine-tuning run(s) + evaluation + model card Weeks 3–4: RAG pipeline + RAGAS evaluation + deployment + documentation

End of month check: All 6 acceptance criteria from Rung 5 spec are met, including: fine-tuned model on HuggingFace Hub, RAGAS scores documented, live demo accessible, stable URL in README. No disqualifiers present.

Writing milestone: LLM fine-tuning observations blog post counts as Blog Post #3. Publish it.

Gate check: Do not begin Month 11 Phase 5 study until the live demo URL is confirmed working and all acceptance criteria are checked off. This is a hard stop.

Month 11 — Phase 5 Preparation + Rung 5 Maintenance¶

No new rung. Use this month to:

Choose the ML task and dataset for Rung 6 (see Rung 6 spec for project choice guidance)
Baseline model should be trained and cross-validated by end of this month
Set up DVC and MLflow locally and run through the tutorial setup
Verify Rung 5 demo is still running (check monthly from now on)
Design the CI/CD pipeline on paper before implementing it — write out the jobs and their dependencies

Month 12 — Rung 6 Ships ⚠️ HARD GATE #2¶

Active build: Rung 6 (Production ML System)

This is a 4-week intensive build with no slack:

Week 1: DVC + MLflow + model registry
Week 2: FastAPI serving + deployment
Week 3: GitHub Actions CI/CD pipeline (must have ≥ 3 successful runs)
Week 4: Evidently monitoring + documentation (README, architecture diagram, runbook)

End of month check: Every item in the Rung 6 acceptance criteria is demonstrable live. The endpoint responds. The Actions tab shows runs. The monitoring report exists with drift detection evidence.

Writing milestone: Production ML failure modes blog post counts as Blog Post #4. Publish it.

Gate check: Do not sit for senior-level ML engineer interviews until this gate is fully open. The gap between “I built something like this” and “here’s the live system” is the entire argument.

Month 13 — Rungs 7 & 8 Ship¶

Active build: Rung 7 (Paper Reproduction) + Rung 8 (Technical Writing final posts)

These two rungs run in parallel because Rung 7 generates the content for Rung 8 Blog Post #5.

Weeks 1–2: Paper selection + independent implementation + initial training runs Weeks 3–4: Analysis (ANALYSIS.md) + extension experiment + blog post + final portfolio polish

End of month check for Rung 7: ANALYSIS.md complete with all 5 required sections. Blog post published. Quantitative results in README.

End of month check for Rung 8: ≥ 3 posts published (5 is target). Engagement evidence documented. All posts linked from GitHub profile README.

Final portfolio sweep (Month 13, Week 4):

Run all test suites across Rungs 1–3. Fix any failures.
Verify all live demos are responding (Rung 5 Spaces, Rung 6 endpoint).
Update GitHub profile README with complete rung table.
Check all HuggingFace model card links.
Ensure all blog posts have stable URLs linked from the correct rung README files.

Portfolio Maintenance Protocol¶

Early rungs decay. Python package versions change. Free hosting services go down. Kaggle changes their API. This section exists because a broken Rung 1 repository at Month 13 tells the worst possible story about your engineering habits.

Monthly Maintenance (15 minutes, no exceptions)¶

Check Rung 5 and Rung 6 live URLs — they must respond
Verify no new GitHub security alerts on your repositories

Quarterly Maintenance (2–3 hours every 3 months)¶

Pull each rung’s repository into a clean environment
Run pip install -r requirements.txt — fix any dependency conflicts
Run the test suite — fix any failures
Update requirements.txt pin versions if needed
Regenerate any stale figures if the underlying data changed
Check that all external links in READMEs (HuggingFace, Kaggle, blog) still resolve

Pre-Interview Check (30 minutes before every technical interview)¶

Confirm Rung 5 Spaces demo is responding (open it in a browser, make a test request)
Confirm Rung 6 API endpoint is returning predictions (test with curl)
Confirm GitHub Actions shows recent passing runs (or document the last passing run date)
Have all GitHub repos open in browser tabs before the interview begins
Know your Rung 5 RAGAS scores and Rung 6 monitoring metrics cold — you will be asked

Updating Early Rungs As You Learn More¶

Your Month 2 self who implemented PCA will be embarrassed by it from the vantage of Month 10. This is correct — it means you’ve grown. But the response to embarrassment should not be deleting the repo; it should be adding a “Retrospective” section to the README that documents what you now know about its limitations.

What to update (acceptable):

README accuracy: fix misleading descriptions, update performance claims if you re-ran experiments
Test additions: if you found a bug, fix it and add a test that would have caught it
Documentation quality: expand MATH_NOTES if your understanding has deepened

What not to update (resist the urge):

Do not retroactively add features to make early rungs look more sophisticated than they were at the time
Do not delete experiments that didn’t work — they are evidence of genuine exploration
Do not back-date commits to make the history look cleaner

The Sprint-to-Portfolio Mapping¶

Every monthly study sprint has a portfolio output. If a sprint produces no public artifact, the sprint’s learning is private — and private learning is invisible in a job search.

Phase	Study Focus	Portfolio Output
Phase 0 (M1–2)	Math, Python, NumPy	Rung 1
Phase 1 (M3–4)	Classical ML, Sklearn, Kaggle	Rung 2
Phase 2 (M5–6)	Deep Learning, Backprop	Rung 3
Phase 3 (M7–8)	Transformers, Attention	Rung 4
Phase 4 (M9–10)	LLMs, PEFT, RAG	Rung 5
Phase 5 (M11–12)	MLOps, Production Systems	Rung 6
Phase 6 (M13)	Research, Writing	Rungs 7 + 8

The portfolio is not separate from the roadmap. It is the external-facing layer of the roadmap. Every hour of study that doesn’t eventually produce a public artifact is preparation for a portfolio artifact that will come later. Nothing is wasted — but everything must eventually become public proof.

Return to README.md · Previous: 09_portfolio_presentation_guide.md