Books give you depth and coherence; online courses bring something different: a time structure, video for concepts that are hard to visualize, auto-graded exercises and, in some cases, certificates. The problem is not finding courses — there are thousands — but choosing the few that genuinely add something after completing this one. In this lesson we select real, well-established courses and specializations, point out which module of this course each one extends and, above all, give you a strategy to avoid the most common trap of the self-taught learner: collecting courses without finishing any.

1. What an online course can give you that this course has not already
2. Andrew Ng's specializations (Coursera / DeepLearning.AI)
3. fast.ai: deep learning top-down
4. Kaggle Learn: micro-courses in notebooks
5. The scikit-learn documentation as a course
6. Advanced level: Stanford CS229 and MIT OpenCourseWare
7. Spanish-language content
8. Comparison table
9. How not to collect courses: the project as the axis

Before signing up for anything, ask yourself what you are after. Having completed the 10 modules of this course, an online course only makes sense if it gives you one of these three things:

• Depth in a specific area (deep learning, mathematical theory) that we covered here at an introductory level.
• Another perspective on the same material: hearing a different teacher explain regularization or gradient descent consolidates what you have learned.
• Additional guided practice with automatic feedback (auto-graded notebooks).

If a course gives you none of the three, it is redundant: do not start it.

• Platform: Coursera (DeepLearning.AI and Stanford).
• Cost: the videos can be audited for free; the certificate and graded labs are paid (Coursera subscription).
• Who it is for: anyone who wants to consolidate the fundamentals with the most didactic video explanation there is. Andrew Ng is probably the most influential ML teacher in the world, and this specialization (heir to his legendary 2011 course, modernized with Python) is a classic for a reason.
• What it adds after this course: it revisits modules 4, 6 and 7 from the inside: it implements gradient descent and logistic regression at a low level, where we used scikit-learn as a well-understood but closed box. It is the "other perspective" par excellence.

• Platform: Coursera (DeepLearning.AI). Cost: same as the previous one.
• Who it is for: anyone who wants to specialize in neural networks after the taste we got in 07-04 and projects 09-02 (CNN) and 09-03 (NLP).
• What it adds after this course: five courses covering neural networks from scratch: foundations, practical tuning, project structuring, CNNs and sequence models. It is the video counterpart of Chollet's book from the previous lesson; many people do both.

• Platform: fast.ai (the Practical Deep Learning for Coders course). Cost: completely free.
• Who it is for: hands-on learners who prefer to start by training state-of-the-art models and understand the theory afterwards.
• What it adds after this course: the opposite philosophy to Andrew Ng's. Where Ng builds bottom-up (mathematics → model), fast.ai goes top-down: in the very first lesson you train a competitive image classifier, and the layers of theory come later. It extends the module 9 projects and exposes you to PyTorch (through the fastai library), a framework we did not use in this course and which dominates research.
• How to approach it: pick either Ng's specialization or fast.ai as your first step into deep learning, depending on your learning style. Doing both at once is a recipe for dropping out.

• Platform: kaggle.com/learn. Cost: free.
• Who it is for: anyone who wants quick, practical refreshers in sessions under an hour.
• What it adds after this course: micro-courses of 3-5 hours (Intro to Machine Learning, Intermediate ML, Feature Engineering, Time Series...) built entirely as notebooks that run in the browser. After this course most of them will feel easy: use them as a warm-up before a Kaggle competition (we will get to that in the next lesson) or for topics we touched only lightly, such as advanced feature engineering (it extends module 3) or time series (which this course did not cover).

• Platform: scikit-learn.org. Cost: free.
• It deserves its own entry because it is one of the most underrated resources around: the scikit-learn User Guide is, in practice, a complete course in classical ML, with conceptual explanations, mathematics and runnable examples for every algorithm, and the examples gallery is a gold mine of quality code.
• What it adds after this course: it is the direct reference for almost everything we did in modules 3 through 7. When you want to truly understand a parameter you once tuned "just because", its User Guide page is the first place to look. Getting used to reading official documentation is, besides, a professional skill in its own right.

• CS229 (Stanford, Machine Learning): the complete lectures of the graduate course are free on YouTube (Stanford Online channel), with lecture notes on the course website. It is the mathematical, rigorous version of Ng's syllabus: full derivations, learning theory. Tackle it only with a grounding in linear algebra and calculus, ideally after reading ISL (previous lesson).
• MIT OpenCourseWare: freely publishes materials and videos from MIT courses, including Introduction to Machine Learning and the excellent mathematical foundations (Gilbert Strang's linear algebra, probability). Useful above all to reinforce the mathematics underpinning modules 2, 4 and 7.

If you also read Spanish, there is a smaller but real pool of quality material:

• Coursera and edX host courses from Spanish-speaking universities and from universities that translate their content; in addition, much of the English-language catalogue (including Ng's specializations) offers Spanish subtitles.
• UNED, UPV, UAB and other Spanish universities publish introductory MOOCs on data science and ML (in Spanish) on platforms such as edX or MiriadaX; their level is usually introductory, so after this course they will serve you more as review than as extension.
• Honest advice for bilingual learners: treat Spanish-language material as support (subtitles, review), not as the backbone of your path; the field's reference courses are in English, and waiting for translations means falling behind.

The most common failure pattern of the self-taught learner has a name: tutorial hell. Sign up for five courses, start three, finish zero. The antidotes:

• One active course at a time. Same as with books. Finishing one mediocre course from start to end teaches more than starting three excellent ones.
• The project leads, the course serves. Invert the relationship: instead of "I'll do the course and then figure out what to build", first define a project of your own (an extension of MercaFresh, a dataset from your industry, a Kaggle competition) and enroll only in the course that unblocks your next step. A course chosen to solve a concrete problem gets finished; one chosen "just in case" gets abandoned.
• The 20% rule: if after completing 20% of a course everything sounds like this one, it is not extension, it is repetition: drop it guilt-free and look for one a level up. Quitting out of redundancy is good judgment; quitting out of laziness is the problem.
• Certificates in their proper place: in ML, a GitHub repository with your own projects carries more weight in an application than a list of certificates. Pay for a certificate only if your work context explicitly values it.

• Mistake: enrolling in an introductory course "to review". After 10 modules, another introductory course is procrastination disguised as study. Go straight to the intermediate level.
• Mistake: watching videos the way you binge a series. Watching 40 videos without opening an editor is not studying. Rule: for every hour of video, at least one hour of your own code.
• Mistake: choosing a course for the certificate rather than the content. The certificate is a by-product, not the goal.
• Tip: audit before you pay. On Coursera almost all the teaching content can be watched for free in audit mode; pay only once you have confirmed the course adds value and you want the graded assignments or the certificate.
• Tip: use playback speed wisely. At 1.25x-1.5x introductory videos go down easily; but when a mathematical derivation arrives, drop back to 1x and pick up pen and paper.

Create a Coursera account (if you do not have one) and audit, for free, the first week of Andrew Ng's Machine Learning Specialization. Compare its explanation of gradient descent with your current intuition after this course, and decide with judgment: does it give you a new perspective, or does the 20% rule apply?

Complete, start to finish, the Intermediate Machine Learning micro-course on Kaggle Learn (3-4 hours). Double goal: review pipelines and validation (modules 3 and 6) in a new environment, and get comfortable with Kaggle notebooks, which you will use in the next lesson.

Define in writing a project of your own (for example: "predict MercaFresh's weekly demand for fruit", or something from your industry) and, starting from it, pick ONE single course from the table that unblocks that project. Write a 12-week plan alternating course weeks and project weeks.

Exercise 1 (guideline): the usual outcome after this course is an in-between position: the concepts will sound familiar (regression, cost, gradient), but seeing them implemented from scratch in Python, without scikit-learn, brings a new kind of understanding. If that is your case, the course passes the filter: it is "another perspective", not repetition. If everything genuinely feels trivial, jump to the Deep Learning Specialization or to CS229.

Exercise 2 (guideline): you should be able to get through it fluently; the sections on pipelines, cross-validation and XGBoost are direct review of modules 3, 6 and 7. The added value is in the data leakage sections (which connect with what we saw in 06-05 about evaluation mistakes) and in getting fluent with Kaggle's notebook interface.

Exercise 3 (guideline): a reasonable plan for the weekly-demand example: weeks 1-2, data exploration and a baseline with what you already know; weeks 3-6, the Time Series micro-course on Kaggle Learn (chosen because time series are exactly what this course did not cover and the project demands); weeks 7-10, applying what you learned to the project; weeks 11-12, honest evaluation and documentation on GitHub. Note the reasoning: the course enters the plan because the project calls for it, not the other way around.

Online courses are a powerful complement when chosen with judgment: Andrew Ng's specializations to consolidate fundamentals with the best video teaching there is, fast.ai for hands-on deep learning, Kaggle Learn for applied bite-size practice, the scikit-learn documentation as a permanent reference, and CS229/MIT OCW when you want mathematical rigor. Strategy matters more than the catalogue: one course at a time, chosen because your project needs it, and your own code for every hour of video. But studying alone has a ceiling: sooner or later you will need to ask, compare and learn from others. That is what the next lesson is about: the communities and forums where machine learning practitioners live.