Open-source project
GokuMohandas/Made-With-ML avatar
GokuMohandas/Made-With-ML

Made With ML: A Full-Stack Course for Production ML, Not Just Models

Learn how to develop, deploy and iterate on production-grade ML applications.

50,021 stars7,817 forksJupyter NotebookMIT

At a glance

What is it?
GokuMohandas/Made-With-ML is a free, MIT-licensed course that walks developers from Jupyter experimentation to a production ML system using Ray, MLOps tooling, and CI/CD. It is a structured learning path, not a library, so its value depends on your willingness to follow its opinionated stack.
Who is it for?
Adopt Made With ML if you are a software engineer or data scientist who wants a guided, end-to-end tour of production ML, especially if you are open to using Ray and Anyscale. Skip it if you prefer framework-agnostic tutorials or if you need a drop-in codebase rather than a learning journey.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 8 months ago.
What is it written in?
Mainly Jupyter Notebook, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • GokuMohandas/Made-With-ML50,021 ★ · +893
Star history
Repository2026-08-182026-11-15
GokuMohandas/Made-With-ML49.1k50k

893 Stars in the last 89 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The Problem: ML Courses Stop at the Notebook

Most ML tutorials end after training a model in a Jupyter notebook. They leave out the hard parts: serving, monitoring, retraining, and integrating with existing software stacks. Made With ML targets that gap. It is a course repository, not a framework, aimed at developers who already code but have never shipped a model to production. The README describes an audience of software engineers, data scientists, college graduates, and product leaders. The core promise is to bridge the gap between university curriculum and industry expectations. If you have built models but never deployed one, this course is aimed directly at you.

The Architecture: From Experiment to Production via Ray

The course is structured as a progression from design and development to deployment and iteration. The key architectural choice is Ray. Ray serves as the distributed compute layer for data processing, training, tuning, and serving. The README emphasizes that you can scale ML workloads in Python without learning new languages. The notebooks walk through a typical ML project, but the production parts rely on Ray's ecosystem, including Ray Serve for model serving and Ray Tune for hyperparameter tuning. The course also connects MLOps components like tracking, testing, and orchestration. The design is iterative: you start with a simple model, then add reliability features such as testing and CI/CD as you go. This is a deliberate pedagogical structure, not just a code dump.

Getting Started: Commands and Configurations

The setup is concrete and command-driven. You start by creating a GitHub repository named Made-With-ML with a README file to establish a main branch. Then you clone the course repo into that directory. Credentials require a .env file with a GITHUB_USERNAME variable. For local setup, the README specifies Python 3.10, creating a virtual environment, installing requirements.txt, and running pre-commit install and pre-commit autoupdate. You also need to export PYTHONPATH to include the current directory. For Anyscale, the setup is simpler because the cluster environment pre-installs dependencies. You create an Anyscale Workspace with specific names for the cluster environment and compute config, such as madewithml-cluster-compute-g5.4xlarge. The course provides toggles for local versus Anyscale instructions, but Anyscale is the default and the recommended path for a one-day cohort.

A Real Limitation: The Anyscale Default and Lock-In

The course is built around Ray, and the default setup assumes you will use Anyscale, a commercial platform. The README says Anyscale instructions are toggled on by default. While local setup is possible, the course notes that local execution will be slower. This creates a dependency: if you want the full experience, you may need to pay for Anyscale compute. The README mentions joining a live cohort with provided structure, compute (GPUs), and community, but that comes with sign-up. For teams that cannot use Anyscale due to cost or policy, the local path works but may feel like a second-class citizen. Also, the course is opinionated about its stack: Ray, pre-commit, and specific MLOps tools. If your organization uses a different orchestration system or a different model serving framework, you will have to translate the lessons, which adds friction.

Alternatives: Comparing to Other Learning Paths

Made With ML is deeply tied to Ray and Anyscale, which makes it more coherent but less portable. Another alternative is the book 'Designing Machine Learning Systems' by Chip Huyen. If you want to learn Ray specifically, the official Ray documentation is the place to start, and this course adds an end-to-end project.

Maintenance and Upgrade Cost

The repository was last pushed in March 2026 and has a recent release v1.1.0. The README instructs users to run pre-commit autoupdate, which suggests the project expects dependencies to change over time. The course content is tied to specific library versions, especially Ray and its ecosystem. When those libraries update, the course may need updates to remain compatible. The MIT license is permissive, so you can fork and modify the content for your own use. However, the maintenance burden is on you: if you use this as a reference, you will need to track changes in Ray and related tools. The course does not appear to offer a versioned API or a library you can import; it is a set of notebooks and scripts. That means upgrading is a matter of re-running the course with newer dependencies, which may break. The active last push date suggests the author is maintaining it, but that is not a guarantee of future support.

Who Should Not Use This Course

This is not a tool you install and use. It is a learning resource. If you need a ready-made ML pipeline to drop into your project, this is the wrong choice. The repository is a course, not a library. If you are already an experienced ML engineer who knows how to deploy models, parts of the course may be too basic. Also, if you are averse to using Ray or Anyscale, you will fight the course's default path. The course's value comes from following its specific workflow. If you prefer to learn by building your own stack, you might find the opinionated nature restrictive. The course is best consumed as a structured walkthrough, not as a reference manual.

Editorial conclusion

Adopt Made With ML if you are a software engineer or data scientist who wants a guided, end-to-end tour of production ML, especially if you are open to using Ray and Anyscale. Skip it if you prefer framework-agnostic tutorials or if you need a drop-in codebase rather than a learning journey. Before starting, verify that your local Python 3.10 environment can install the requirements and that you are comfortable with the Anyscale-first setup, as the default instructions assume you will use Anyscale. Then clone the repo and run the notebook to see if the teaching style matches your pace.

Frequently asked questions

What is MLOps, as Made With ML teaches it?

The course frames MLOps as connecting the components, specifically tracking, testing, serving and orchestration, into one end to end system, and moving from experimentation in design and development to production in deployment and iteration. It also sets a goal of getting there without changes to your code or infrastructure management, using CI/CD workflows to train and deploy models in a modular way.

What does Made With ML ask me to install locally?

A virtual environment with Python 3.10, then `python3 -m pip install -r requirements.txt`, then `pre-commit install` and `pre-commit autoupdate`. The setup also exports `PYTHONPATH` to the working directory so the `madewithml/` package is imported from the checkout rather than installed, and recommends pyenv or pyenv-win to manage the interpreter.

Can I work through Made With ML without a GPU cluster?

Yes. The Local track uses your personal laptop as the cluster, with one CPU as the head node and the remaining CPUs as workers, and the README states that all of the code works on a personal laptop, only slower than a larger cluster. The Anyscale track is the one that supplies GPUs, through a compute config named `madewithml-cluster-compute-g5.4xlarge`.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/gokumohandas-made-with-ml.svg)](https://hysenlabs.com/projects/gokumohandas-made-with-ml)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/gokumohandas-made-with-ml.svg)](https://hysenlabs.com/projects/gokumohandas-made-with-ml)

Was this useful?