I Rebuilt the scikit-learn Cheat Sheet That Got Me Through My First Year in ML

A weekend homage to the flowchart every beginner traces — turned into something you can actually search.

If you started learning machine learning in the last decade, there’s a good chance you’ve seen this picture. A bright START bubble in the corner. A trail of pale-blue decision bubbles — more than 50 samples? predicting a category? fewer than 100K samples? — branching out into four color-coded continents: classification, regression, clustering, dimensionality reduction. And tucked into the middle, the single funniest node in all of machine learning documentation: tough luck.

This is the scikit-learn algorithm cheat-sheet. Years ago, when I was a novice data scientist, I lived by it.

I’m not exaggerating. When you’re new, the hardest part of machine learning isn’t the math — it’s the paralysis. You have a problem and a vague sense that “ML can do this,” and then you stare at a wall of names — SVM, random forest, k-means, PCA — with no idea which one is for you. This flowchart was the hand on my shoulder saying start here, answer these questions, and you’ll land somewhere reasonable. I traced its arrows more times than I can count. It turned an intimidating field into a map I could follow.

So this is, first and foremost, a thank-you note to that little diagram. And then it’s the story of what happened when, years later and just for fun, I decided to build my own version of it.

What the flowchart got right (and where I kept wishing for more)

The genius of the cheat-sheet is that it meets a beginner exactly where they are. It doesn’t ask you to already know the algorithms — it asks you simple questions about your data and your goal, and the algorithm names fall out the other end. That’s the right pedagogy. It demystified the whole landscape for me in a way no textbook chapter did.

But the more I leaned on it, the more I bumped into its edges — not flaws, just the natural limits of a single static image:

• It’s one fixed path. You follow the arrows the diagram chose. You can’t ask it your own question in your own words.
• It’s scoped to scikit-learn. Which is fair — it’s their cheat-sheet. But it means whole territories are off the map: time-series forecasting, deep learning, recommendation systems, and causal inference (the “did this change actually cause the outcome?” question that turns out to matter constantly in the real world).
• It encodes the tradeoffs implicitly. The bubbles quietly bake in things like sample size, but it can’t show you the dimension I cared about most once I was working with real stakeholders: how interpretable is this thing? Sometimes a model you can explain beats a model that’s slightly more accurate.

None of that is a knock. It was perfect for what it was. I just kept daydreaming about a version I could query instead of trace.

So I built one — for fun

I’m comfortable in the field now, which is exactly why this was a fun weekend project instead of a stressful one. I didn’t set out to replace a classic — you can’t replace a classic. I set out to make the iteration I’d wished for at 22, mostly for the joy of building it.

It’s live here: ml-algo-selector.vector1.ai

Same spirit as the flowchart — get a beginner from “I have a problem” to “here are some reasonable algorithms” — but with a few upgrades the static image couldn’t offer:

You start from your own words. Type a use case in plain language — “forecast monthly sales,” “detect fraudulent transactions,” “segment customers” — and it recognizes the kind of task and surfaces the algorithms that fit. No tracing arrows; just describe what you’re trying to do.

You can sort by what actually matters to you. Re-rank the results by interpretability, training speed, or how much data they need. That interpretability dimension is the one I most wished the original had — it’s often the deciding factor in practice.

It covers the continents the flowchart left off the map. Forty-plus algorithms across eleven task families, including forecasting, natural language, computer vision, recommendation, and causal inference. Each one expands into when to reach for it, its strengths, what to watch out for, the usual Python libraries, and a link straight to the official docs.

It’s the same friendly idea, just queryable — and a little broader, because the field got broader.

What it is, and what it isn’t

In the spirit of the honest beginner I was, let me be clear about the boundaries.

It’s a fast, opinionated starting point — a way to go from a vague problem to a shortlist plus the docs to learn them. It is not magic. It doesn’t touch your data or run any models. The matching is curated keyword-and-intent logic (it knows “forecasting” and “forecasted” are the same, and that “fraud” points at both anomaly detection and classification), not a model that understands your problem. The ratings are rules of thumb, not benchmarks. And just like the flowchart, it will never replace the actual work: try a dumb baseline first, then iterate.

The cheat-sheet was a map, not the territory. So is this.

The build: boring tech on purpose

The decision I’m happiest with: the whole thing is one self-contained HTML file. No backend, no build step, no framework, no database. The algorithm catalog is a JavaScript array, the matching is a handful of small functions, and the styling is plain CSS.

That was deliberate. A for-fun project dies the moment it needs a server to babysit or an API that sends you a bill. A single static file runs entirely in the visitor’s browser, costs nothing to host, and the file I previewed locally is byte-for-byte the one that went live. Anyone can open it in a text editor and understand the entire thing — which feels appropriately in the spirit of a tool meant to demystify.

The part nobody warns you about: shipping it

Building it was the easy weekend. Publishing it on my own domain is where things got humbling.

The plan was simple: host the static file free on Netlify (drag, drop, done), then point a subdomain — ml-algo-selector.vector1.ai — at it. Pointing a subdomain means adding one DNS record, a CNAME. Conceptually trivial. In practice I fat-fingered it twice in one form: misspelled "algo" as "aglo," and pasted the target with an https:// prefix and a trailing slash when a CNAME wants the bare hostname. Two tiny typos, and nothing works — silently.

Then came the moment that gets everyone. I fixed the record, the domain verified, I clicked the link, and the browser threw up a full-page red “Your connection is not private” warning. My stomach dropped.

But nothing was broken. Getting a domain to point at your host (DNS) and getting it a security certificate (HTTPS) are two separate events, and the certificate is issued after the DNS propagates. For a few minutes, the browser saw a domain with no matching certificate yet and panicked on my behalf. The fix was the hardest thing in software: wait. The certificate provisioned itself, the warning vanished, the padlock appeared.

If you take one practical thing from this article: a scary certificate error right after setting up a domain is almost always just the waiting period, not a mistake. Don’t undo your work. Go make tea.

Full circle

That flowchart handed me a map when I was lost in a field that felt impossibly large. Rebuilding it — searchable, sortable, a little broader — was my way of redrawing that map for whoever’s standing where I stood, and, honestly, mostly for the pure fun of making something.

So if you’re early in your ML journey and frozen on “which algorithm do I even use?”, go kick the tires: ml-algo-selector.vector1.ai. And if it gets your use case wrong, tell me — I’ll add it.

And if you’ve never seen the original scikit-learn cheat-sheet: go find it. It’s still wonderful. Tough luck is still in there.

Built in a weekend. One HTML file, zero servers, one DNS-induced heart attack — and a lot of gratitude to a flowchart.

About the Author

Brian Curry is a Kansas City-based data scientist and applied AI researcher with two decades of enterprise experience across retail, agriculture, energy, hospitality, telecommunications, and media. He is the founder of Vector1 Research, an independent lab focused on applied AI, causal inference, agentic systems, and the economics of intelligent organizations. His work centers on building systems that surface the causal and structural drivers of performance — bridging advanced analytics, machine learning, and executive decision-making. He writes regularly on Medium about applied AI, knowledge engineering, decision science, and the engineering disciplines that make machine learning actually work in production.