Repository navigation
Expand file tree
/
Copy pathresources.txt
More file actions
1613 lines (1003 loc) · 44.5 KB
/
Copy pathresources.txt
File metadata and controls
1613 lines (1003 loc) · 44.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
I researched this with a bias toward **official documentation, university material, open textbooks, practitioner-recommended books, hands-on labs, and resources that working engineers actually keep using after the tutorial phase**. I also cross-checked current Reddit discussions rather than relying entirely on SEO “top 10 courses” articles. A recurring practitioner recommendation was to learn the underlying systems, build real things, and use documentation/books to solve problems rather than accumulating courses. ([Reddit][1])
**Legend:** `CORE` = I would actually work through it; `HANDS-ON` = do the exercises; `REFERENCE` = consult when needed; `BOOK` = worth owning/reading selectively; `DEEP OPTIONAL` = only if time permits. I have deliberately **not made YouTube part of the curriculum**. There is enough excellent text-based material to complete the entire roadmap without it.
---
# 0. Foundation Reset — 3–4 weeks
This phase should make Python, Git, SQL, HTTP, operating systems, debugging, testing, basic algorithms, and terminal work feel routine.
### 0.1 Python — `CORE · FREE`
**The Python Tutorial — official Python documentation**
[Python 3.14 Tutorial](https://docs.python.org/3/tutorial/)
Because you're already a professional developer, don't read it like a beginner course. Concentrate on:
* functions and argument semantics
* data structures
* modules/packages
* exceptions
* classes and Python's object model
* iterators/generators
* context managers
* standard library
* virtual environments
* logging
* threading
The current official tutorial is specifically written for programmers who already understand programming. ([Python documentation][2])
Also bookmark:
[Python asyncio documentation](https://docs.python.org/3/library/asyncio.html)
Learn enough to clearly explain:
`asyncio` vs threads vs processes vs true parallelism.
---
### 0.2 Developer tooling / shell — `CORE · FREE TEXT`
**MIT — The Missing Semester of Your CS Education**
[MIT Missing Semester 2026](https://missing.csail.mit.edu/2026/)
This is unusually well aligned with your goal. The 2026 course covers the shell, command-line environment, development tools, debugging/profiling, Git, packaging/shipping and code quality. You can use the written materials and ignore the YouTube recordings. ([Missing Semester][3])
**Do:** Shell → Command-line Environment → Development Tools → Debugging & Profiling → Git → Packaging/Shipping → Code Quality.
---
### 0.3 Git — `CORE · FREE BOOK`
**Pro Git — Scott Chacon & Ben Straub**
[Read Pro Git free](https://git-scm.com/book/en/v2)
The full book is legally available free online. ([Git scm][4])
Don't read all of it. Study:
* Ch. 2 — Git Basics
* Ch. 3 — Git Branching
* 7.3 — Stashing/Cleaning
* 7.6 — Rewriting History
* 7.7 — Reset Demystified
* 7.8 — Advanced Merging
* 7.10 — Debugging with Git
* selected parts of Ch. 10 — Git Internals
You should become comfortable with:
`rebase`, `reflog`, `reset`, `revert`, `bisect`, cherry-picking and conflict resolution.
---
### 0.4 Operating systems — `CORE · FREE BOOK`
**Operating Systems: Three Easy Pieces — Arpaci-Dusseau & Arpaci-Dusseau**
[OSTEP free online book](https://pages.cs.wisc.edu/~remzi/OSTEP/)
One of the strongest free CS books available. It focuses on the three major OS areas: virtualization, concurrency and persistence. ([UW Computer Sciences][5])
Do **not** read the entire textbook now.
Read selectively:
* Processes
* Process API
* CPU scheduling overview
* Address spaces
* Memory API
* Paging basics
* Concurrency and threads
* Locks
* Condition variables
* Files and directories
* I/O devices
This pays off later when Docker, Kubernetes and production debugging stop looking magical.
---
### 0.5 Data structures & algorithms — `REFRESH · FREE BOOK`
**Open Data Structures**
[Open Data Structures](https://opendatastructures.org/)
Use it to revise:
* arrays / dynamic arrays
* linked structures
* stacks / queues
* hash tables
* binary trees
* heaps
* graphs
* BFS / DFS
* complexity analysis
([Open Data Structures][6])
You do **not** need six months of LeetCode for this transition.
---
### 0.6 SQL / PostgreSQL — `CORE · FREE`
**PostgreSQL official tutorial**
[PostgreSQL Tutorial](https://www.postgresql.org/docs/current/tutorial.html)
Then:
**PostgreSQL Exercises**
[PostgreSQL Exercises](https://www.pgexercises.com/)
PGExercises goes from basic queries through joins, aggregation, window functions and recursive queries. ([PG Exercises][7])
Pay special attention to:
* indexes
* transactions
* isolation
* joins
* query plans
* constraints
* window functions
Later, system design will require understanding databases beyond `SELECT`.
---
### 0.7 HTTP / Web architecture — `CORE · FREE`
**MDN HTTP Guides**
[MDN HTTP overview](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Overview)
Then use:
[MDN HTTP guides](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides)
Specifically:
* request/response lifecycle
* methods
* status codes
* headers
* authentication
* caching
* cookies
* CORS
* HTTP/1.1 vs HTTP/2 vs HTTP/3
* HTTPS/TLS relationship
MDN's overview explicitly walks through the client → connection → request → response flow. ([MDN Web Docs][8])
---
### 0.8 Testing — `CORE · FREE`
**pytest documentation**
[pytest documentation](https://docs.pytest.org/en/stable/)
Focus on:
* fixtures
* parametrization
* mocking
* exception testing
* temporary resources
* unit vs integration tests
You should be able to test FastAPI/database code without treating testing as a separate chore.
### Foundation study order
**Python → Missing Semester → Git → OSTEP → HTTP → SQL/Postgres → pytest → DSA refresh.**
---
# Month 1 — Linux + Networking
## Linux
### 1.1 The Linux Command Line — `CORE · FREE BOOK/PDF`
**William Shotts — The Linux Command Line**
[The Linux Command Line](https://linuxcommand.org/tlcl.php)
This is one of the best text-first Linux introductions and is legally available from the author's site. ([LinuxCommand][9])
Read selectively around:
* filesystem
* permissions
* processes
* shell expansion
* redirection
* pipes
* grep
* regular expressions
* process management
* shell scripting
* environment
* networking commands
---
### 1.2 Linux Journey — `HANDS-ON · FREE`
[Linux Journey](https://linuxjourney.com/)
Use it as the shorter structured companion to TLCL.
---
### 1.3 OverTheWire Bandit — `HANDS-ON · FREE`
[OverTheWire Bandit](https://overthewire.org/wargames/bandit/)
Do roughly the first 20–25 levels.
It forces you to actually use SSH, `find`, permissions, pipes, redirection and shell utilities rather than merely recognize the commands. ([OverTheWire][10])
---
## Networking
### 1.4 Beej's Guide to Network Concepts — `CORE · FREE BOOK/PDF`
[Beej's Guide to Network Concepts](https://beej.us/guide/bgnet0/)
Excellent fit because it assumes Python familiarity and teaches the networking concepts underneath applications. HTML and downloadable PDFs are provided. ([Beej][11])
Cover:
* network layers
* IP addressing
* subnets
* routing
* TCP
* UDP
* ports
* DNS
* NAT
* sockets
---
### 1.5 Computer Networking: Principles, Protocols and Practice — `DEEP REFERENCE · FREE BOOK`
[Computer Networking: Principles, Protocols and Practice](https://www.computer-networking.info/)
Use for deeper explanations of:
* TCP
* routing
* DNS
* HTTP
* transport/network layers
Don't read cover-to-cover.
---
### 1.6 Beej's Guide to Network Programming — `OPTIONAL DEEP PRACTICE · FREE`
[Beej's Guide to Network Programming](https://beej.us/guide/bgnet/)
Write one tiny TCP server/client yourself.
That single exercise makes a surprising amount of networking terminology concrete.
### Month 1 study order
**TLCL + daily Linux use → Bandit → Beej Network Concepts → manually deploy FastAPI/Nginx → deeper networking only when something breaks.**
---
# Month 2 — Docker
### 2.1 University of Helsinki — DevOps with Docker — `CORE + HANDS-ON · FREE`
[DevOps with Docker 2026](https://devopswithdocker.com/)
This is an actual University of Helsinki MOOC and remains part of its current computer-science offering. ([University of Helsinki][12])
This would be my **main Month 2 curriculum**.
---
### 2.2 Docker official build best practices — `CORE · FREE`
[Docker build best practices](https://docs.docker.com/build/building/best-practices/)
Covers exactly the production details tutorials often omit:
* multi-stage builds
* base-image selection
* build cache
* `.dockerignore`
* ephemeral containers
* pinning versions
* CI builds
([Docker Documentation][13])
---
### 2.3 Docker Compose docs — `REFERENCE · FREE`
[Docker Compose documentation](https://docs.docker.com/compose/)
Also specifically:
[Docker Compose networking](https://docs.docker.com/reference/compose-file/networks/)
Containers on a Compose network can resolve one another by service name; understanding this is important before Kubernetes service discovery. ([Docker Documentation][14])
---
### 2.4 Docker storage / volumes — `REFERENCE · FREE`
[Docker volumes documentation](https://docs.docker.com/engine/storage/volumes/)
Make sure you actually understand:
**image vs container writable layer vs bind mount vs named volume.**
---
### 2.5 Docker Deep Dive — Nigel Poulton — `OPTIONAL PAID BOOK`
Useful if you prefer a coherent book after the MOOC.
I would **not** replace your hands-on work with it. Current practitioner discussion also strongly favors learning Docker by running and breaking actual containerized systems. ([Reddit][15])
### Month 2 study order
**Helsinki course → official Docker docs alongside it → containerize your own stack → intentionally break volumes/network/config → book only for gaps.**
---
# Month 3 — AWS Cloud Engineering
### 3.1 AWS Skill Builder — `CORE · MOSTLY FREE`
[AWS Skill Builder](https://aws.amazon.com/training/digital/)
AWS currently offers **1,000+ free learning resources**, including hundreds of free self-paced courses. ([Amazon Web Services, Inc.][16])
Use Skill Builder for:
* cloud fundamentals
* IAM
* EC2
* networking/VPC
* S3
* databases
* monitoring
Do not turn the month into certification preparation.
---
### 3.2 AWS Well-Architected Framework — `CORE · FREE`
[AWS Well-Architected Framework](https://docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html)
Extremely important because it teaches you to judge architecture using:
* operational excellence
* security
* reliability
* performance efficiency
* cost optimization
* sustainability
([AWS Documentation][17])
Read the **general design principles**, then Security, Reliability and Operational Excellence first.
---
### 3.3 AWS Architecture Center — `CORE REFERENCE · FREE`
[AWS Architecture Center](https://aws.amazon.com/architecture/)
Use this to study real reference architectures and compare them against your own diagrams. ([Amazon Web Services, Inc.][18])
Especially useful:
[AWS Reference Architecture Diagrams](https://aws.amazon.com/architecture/reference-architecture-diagrams/)
---
### 3.4 Amazon Builders' Library — `CORE DEEP READING · FREE`
[Amazon Builders' Library](https://aws.amazon.com/builders-library/)
This is one of the highest-value resources in the entire roadmap.
It consists of articles written by Amazon senior engineers/technical leaders explaining how Amazon architects, releases and operates systems. It is free and grounded in real-world systems. ([Amazon Web Services, Inc.][19])
Start with topics around:
* timeouts
* retries
* backoff and jitter
* overload
* availability
* deployment safety
* caching
* idempotency
Don't read the whole library in Month 3. Keep using it throughout the year.
---
### 3.5 AWS official service docs — `REFERENCE`
For this month bookmark rather than “study”:
* IAM
* VPC
* EC2
* S3
* RDS
* ECR
* ALB
* Route 53
* CloudWatch
* Secrets Manager
Look things up while implementing them.
### Month 3 study order
**Skill Builder fundamentals → manually build architecture → Well-Architected → Architecture Center → Builders' Library alongside problems.**
---
# Month 4 — CI/CD + DevOps
### 4.1 GitHub Actions — `CORE + HANDS-ON · FREE`
[GitHub Actions documentation](https://docs.github.com/en/actions/get-started)
Start with:
[GitHub Actions Quickstart](https://docs.github.com/en/actions/get-started/quickstart)
GitHub's documentation covers CI/testing/deployment workflows directly. ([GitHub Docs][20])
Build your real pipeline while reading.
---
### 4.2 The Twelve-Factor App — `CORE · FREE`
[The Twelve-Factor App](https://www.12factor.net/)
Still worth knowing as a vocabulary/framework for deployable services:
* configuration
* backing services
* processes
* dev/prod parity
* logs
* disposability
([12factor.net][21])
Don't treat all 12 factors as unquestionable laws; understand the motivation.
---
### 4.3 OWASP CI/CD Security Cheat Sheet — `CORE · FREE`
[OWASP CI/CD Security Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/CI_CD_Security_Cheat_Sheet.html)
Read it when your pipeline is operational.
It covers:
* pipeline permissions
* secret management
* dependency risks
* third-party integrations
* artifact integrity
* logging
([OWASP Cheat Sheet Series][22])
---
### 4.4 Google SRE Books — `CORE REFERENCE · FREE BOOKS`
[Google SRE Books](https://sre.google/books/)
The books are available online from Google. ([Google SRE][23])
For Month 4, read selected chapters from:
**Site Reliability Engineering**
* automation
* release engineering
* monitoring
* handling overload
**The Site Reliability Workbook**
* SLOs
* monitoring
* incident response
Do not read both books linearly.
---
### 4.5 Accelerate — Forsgren, Humble, Kim — `RECOMMENDED PAID BOOK`
**Accelerate: The Science of Lean Software and DevOps**
This is less about writing YAML and more about understanding what high-performing software delivery actually looks like.
---
### 4.6 Continuous Delivery — Jez Humble & David Farley — `DEEP OPTIONAL BOOK`
Excellent foundational book, but large. Use selectively for:
* deployment pipeline principles
* testing
* environments
* deployment strategies
### Month 4 study order
**Build GitHub Actions pipeline → Twelve-Factor → OWASP → selected Google SRE chapters → Accelerate.**
---
# Month 5 — Terraform / Infrastructure as Code
### 5.1 HashiCorp AWS Get Started — `CORE + HANDS-ON · FREE`
[Terraform AWS Get Started](https://developer.hashicorp.com/terraform/tutorials/aws-get-started)
Official step-by-step exercises covering create/manage/destroy infrastructure. ([HashiCorp Developer][24])
Start here.
---
### 5.2 Terraform State — `CORE · FREE`
[Terraform State tutorials](https://developer.hashicorp.com/terraform/tutorials/state)
This is **mandatory**, not an advanced extra.
Terraform state maps your configuration to actual infrastructure and is central to how Terraform plans changes. ([HashiCorp Developer][25])
Understand:
* local state
* remote state
* locking
* import
* drift
* moves
* state recovery implications
---
### 5.3 Terraform Modules — `CORE · FREE`
[Terraform Modules tutorials](https://developer.hashicorp.com/terraform/tutorials/modules)
Learn both consuming and creating modules. ([HashiCorp Developer][26])
---
### 5.4 Terraform testing — `HANDS-ON · FREE`
[Terraform Tests tutorial](https://developer.hashicorp.com/terraform/tutorials/configuration-language/test)
Modern Terraform has native testing support, including ephemeral test infrastructure and mocks. ([HashiCorp Developer][27])
---
### 5.5 Terraform AWS-service tutorials — `REFERENCE · FREE`
[Terraform AWS service tutorials](https://developer.hashicorp.com/terraform/tutorials/aws)
Use when implementing ALBs, RDS, Auto Scaling, IAM, etc. ([HashiCorp Developer][28])
---
### 5.6 Terraform: Up & Running, 3rd Edition — Yevgeniy Brikman — `OPTIONAL PAID BOOK`
Good for deeper architectural patterns.
But keep the official docs authoritative because Terraform evolves. Recent practitioner recommendations similarly emphasize building real infrastructure plus official docs over memorizing commands. ([Reddit][1])
### Month 5 study order
**AWS Get Started → reproduce your AWS architecture → State → Modules → drift/import → testing → book selectively.**
---
# Month 6 — Machine Learning Fundamentals
This month deserves high-quality theory rather than ten random tutorials.
### 6.1 Introduction to Statistical Learning with Applications in Python — `CORE · FREE BOOK`
**Gareth James, Daniela Witten, Trevor Hastie, Robert Tibshirani, Jonathan Taylor**
[An Introduction to Statistical Learning](https://www.statlearning.com/)
This should be your **main ML fundamentals book**.
Recommended chapters:
* Ch. 2 — Statistical Learning
* Ch. 3 — Linear Regression
* Ch. 4 — Classification
* Ch. 5 — Resampling Methods
* Ch. 6 — Linear Model Selection / Regularization
* Ch. 8 — Tree-Based Methods
* Ch. 9 — Support Vector Machines
* Ch. 12 — Unsupervised Learning
Do the Python labs.
Recent ML community discussions continue to recommend ISLP very strongly for fundamentals. ([Reddit][29])
---
### 6.2 Google Machine Learning Crash Course — `CORE REFRESH · FREE`
[Google ML Crash Course](https://developers.google.com/machine-learning/crash-course/)
It includes text, interactive visualizations and exercises, so you can simply skip its videos. ([Google for Developers][30])
Focus on:
* linear regression
* logistic regression
* classification
* numerical/categorical data
* overfitting/generalization
* neural-net basics
* production ML systems
---
### 6.3 scikit-learn MOOC — `HANDS-ON · FREE`
[scikit-learn MOOC](https://inria.github.io/scikit-learn-mooc/)
Excellent practical complement to ISLP.
Use it for:
* preprocessing
* pipelines
* cross-validation
* hyperparameter tuning
* evaluation
* model selection
---
### 6.4 Mathematics for Machine Learning — `REFERENCE · FREE BOOK`
**Marc Peter Deisenroth, A. Aldo Faisal, Cheng Soon Ong**
[Mathematics for Machine Learning](https://mml-book.github.io/)
Do **not** delay ML for two months while reading math.
Use selectively for:
* linear algebra
* vector calculus
* probability
* optimization
Treat it as a gap-filler.
---
### 6.5 Hands-On Machine Learning with Scikit-Learn and PyTorch — Aurélien Géron — `RECOMMENDED PAID BOOK`
The recent edition uses PyTorch.
Very useful as your **implementation-oriented reference** alongside ISLP.
Don't try to read both books cover-to-cover simultaneously.
### Month 6 study order
**Google MLCC fast pass → ISLP + labs as main curriculum → scikit-learn MOOC → build project → Mathematics for ML only when theory gaps appear.**
---
# Month 7 — PyTorch + Deep Learning
### 7.1 Official PyTorch: Learn the Basics — `CORE + HANDS-ON · FREE`
[PyTorch Learn the Basics](https://docs.pytorch.org/tutorials/beginner/basics/intro.html)
The current sequence covers:
* tensors
* datasets / DataLoaders
* transforms
* network construction
* autograd
* optimization
* saving/loading
([PyTorch Documentation][31])
Do all of it.
---
### 7.2 Understanding Deep Learning — Simon J.D. Prince — `CORE THEORY`
[Understanding Deep Learning author site](https://udlbook.github.io/udlbook/)
The published MIT Press edition is an excellent modern deep-learning book; the author has also published draft material and notebooks online. The book deliberately aims for a pragmatic middle ground between theory and practice. ([MIT Press][32])
Use it for:
* supervised learning
* neural networks
* loss functions
* training
* gradients
* optimization
* regularization
* CNNs
* transformers
This is the deep-learning book I'd prioritize for you.
---
### 7.3 Dive into Deep Learning — `HANDS-ON REFERENCE · FREE`
[Dive into Deep Learning](https://d2l.ai/)
Interactive textbook with mathematics and implementations.
Use the **PyTorch** sections.
Particularly good when you want another implementation of something you just studied theoretically.
---
### 7.4 Stanford CS231n notes — `REFERENCE · FREE`
[Stanford CS231n notes](https://cs231n.github.io/)
Even if you don't specialize exclusively in CV, the notes on:
* backprop
* optimization
* training neural networks
* CNNs
are very useful.
---
### 7.5 Hugging Face LLM Course — `OPTIONAL / TRANSFORMERS · FREE`
[Hugging Face LLM Course](https://huggingface.co/learn/llm-course/en/chapter1/1)
Completely free and covers Transformers, Datasets, Tokenizers, Accelerate and modern NLP/LLM workflows. ([Hugging Face][33])
Use this **after** you understand PyTorch training.
Don't start Month 7 by hiding behind high-level Transformers APIs.
### Month 7 study order
**PyTorch official tutorial → train basic networks yourself → Understanding Deep Learning → D2L exercises → specialize into CV/transformers.**
---
# Month 8 — ML Engineering + MLflow
This month is where you stop thinking only about model accuracy.
### 8.1 Google's Rules of Machine Learning — `CORE · FREE`
[Rules of Machine Learning](https://developers.google.com/machine-learning/guides/rules-of-ml)
Read all 43 rules.
It explicitly emphasizes robust pipelines, simple models first, metrics, iteration and avoiding training-serving skew. ([Google for Developers][34])
Extremely relevant to your transition.
---
### 8.2 Hidden Technical Debt in Machine Learning Systems — `MANDATORY PAPER · FREE PDF`
**Sculley et al., Google**
[Read the paper PDF](https://papers.nips.cc/paper/5656-hidden-technical-debt-in-machine-learning-systems.pdf)
Only a paper, so read the whole thing.
It covers problems such as:
* data dependencies
* entanglement
* glue code
* feedback loops
* configuration debt
* undeclared consumers
* changing external environments
([NeurIPS Papers][35])
This is one of the most valuable items in the whole roadmap.
---
### 8.3 Made With ML — `CORE · FREE TEXT COURSE`
[Made With ML MLOps Course](https://madewithml.com/courses/mlops/)
It covers design, data, training, tracking, serving, testing, reproducibility, production, CI/CD and monitoring. ([Made With ML][36])
For Month 8 prioritize:
* Design
* Training
* Tracking
* Serving
* Testing
* Reproducibility
---
### 8.4 MLflow Tracking — `CORE + HANDS-ON · FREE`
[MLflow Tracking documentation](https://mlflow.org/docs/latest/ml/tracking/)
MLflow Tracking records parameters, code versions, metrics, artifacts and dataset information across runs. ([MLflow AI Platform][37])
Start with:
[MLflow Tracking Quickstart](https://mlflow.org/docs/latest/ml/tracking/quickstart/)
Then deploy your own tracking server.
---
### 8.5 MLflow Model Registry — `CORE + HANDS-ON · FREE`
[MLflow Model Registry](https://mlflow.org/docs/latest/ml/model-registry/)
Learn:
* model versions
* lineage
* aliases
* tagging
* registry lifecycle
([MLflow AI Platform][38])
Then:
[Model Registry tutorial](https://mlflow.org/docs/latest/ml/model-registry/tutorial)
---
### 8.6 Full Stack Deep Learning — `SELECTED MATERIAL · FREE`
[Full Stack Deep Learning 2022](https://fullstackdeeplearning.com/course/2022/)
Although videos exist, the pages contain notes, slides and labs. The material is free. ([Full Stack Deep Learning][39])
Use:
* Development Infrastructure & Tooling
* Experiment Management
* Troubleshooting & Testing
* Data Management
Ignore the rest for now.
---
### 8.7 Designing Machine Learning Systems — Chip Huyen — `RECOMMENDED PAID BOOK`
One of the better books for the bridge from ML modelling into production systems.
Read selectively beginning Month 8 and continue through Month 11.
### Month 8 study order
**Rules of ML → Hidden Technical Debt → Made With ML → MLflow → refactor your existing model into a reproducible ML system → Chip Huyen.**
---
# Month 9 — MLOps Lifecycle
### 9.1 Google's MLOps: Continuous Delivery and Automation Pipelines — `CORE · FREE`
[Google MLOps architecture guide](https://docs.cloud.google.com/architecture/mlops-continuous-delivery-and-automation-pipelines-in-machine-learning)
Even though it uses Google Cloud terminology, the **CI/CD/CT architecture is vendor-independent conceptually**.
It specifically covers continuous integration, continuous delivery and continuous training for ML systems. ([Google Cloud Documentation][40])
Read this before reaching for orchestration tools.
---
### 9.2 MLOps Principles — ml-ops.org — `CORE · FREE`
[MLOps Principles](https://ml-ops.org/content/mlops-principles)
Covers:
* versioning
* testing
* automation
* reproducibility
* deployment
* monitoring
* CI/CD/CT
The material is published under Creative Commons. ([ML Ops][41])
---
### 9.3 DataTalksClub MLOps Zoomcamp — `CORE HANDS-ON · FREE`
[MLOps Zoomcamp](https://datatalks.club/docs/courses/mlops-zoomcamp/)
It is currently available self-paced and covers the complete production ML lifecycle. ([DataTalks.Club][42])
Because you don't want YouTube, use:
* course documentation
* repository
* homework
* code
* project instructions
Focus on modules around:
* experiment tracking
* orchestration
* deployment
* monitoring
* best practices