Build a Simple Recommendation System with Your Teen (Movies, Books, or Games)

Why a recommendation system is a perfect teen ML project

Recommendation engines are behind the “Because you watched…” rows on Netflix, “Suggested for you” on Amazon, and game storefront recommendations. That makes them one of the most motivating ways to introduce machine learning—because teens can feel the results.

For parents, this is also a great “real-world skills” project. It combines:

• Data literacy: collecting, cleaning, and organizing ratings
• Python fundamentals: lists, dictionaries, functions, files
• Intro machine learning thinking: similarity, patterns, and evaluation
• Ethics and critical thinking: bias, privacy, and “filter bubbles”

And the best part: you don’t need advanced math or huge datasets to get something working. This is a very doable machine learning recommendation system beginner build—ideal as a python recommendation project for teens or one of those standout ai project ideas high school students can show in a portfolio.

Pick a recommendation style (and keep it simple)

There are many kinds of recommenders, but for a first recommendation system project for students, two approaches are teen-friendly and fast to prototype.

Option A: Content-based (recommended for weeknight projects)

You recommend items similar to what the teen already likes, based on item “features” (genre, theme, platform, length).

• Works with small datasets
• Easy to understand and debug
• Doesn’t require other people’s ratings

Example: “Recommend games similar to Stardew Valley based on genre = cozy, simulation, crafting.”

Option B: Collaborative filtering (classic recommender concept)

You recommend items based on patterns in ratings from multiple users. “People similar to you liked…”

• Feels like “real” ML even without heavy algorithms
• Great family activity: siblings/parents become “users”
• Can be implemented with simple similarity formulas

In this post we’ll build a tiny collaborative filtering recommender in Python using a small ratings table you can create yourselves. It’s a powerful demo without needing deep ML libraries.

Build it together in Python (a 60–90 minute project)

Below is a step-by-step build you can do with your teen. Use movies, books, or games—whatever they’re excited about.

Step 1: Create your mini dataset (start with 6–10 items)

Pick a theme your teen cares about. Examples:

• Movies: superhero, animation, horror, rom-com
• Books: fantasy, dystopian, mystery
• Games: indie, co-op, story-driven

Have 3–6 people rate items from 1–5 (or 0–5). If it’s just you and your teen, you can still do it, but 3+ users makes recommendations more interesting.

Here’s a sample ratings table you can copy into a CSV or type directly in code.

User	Item	Rating (1–5)
Ava	Spider-Verse	5
Ava	Dune	3
Ava	Mario Odyssey	4
Ben	Spider-Verse	4
Ben	Dune	5
Ben	Hades	5
Cara	Spider-Verse	5
Cara	Mario Odyssey	5
Cara	Hades	4
Dev	Dune	4
Dev	Hades	5
Dev	Celeste	4

Actionable tip: keep at least 2 overlapping items between any pair of users. Overlap is what makes collaborative filtering work.

Step 2: Represent ratings in Python

You can store ratings as a nested dictionary:

• ratings[user][item] = rating

Example:

• ratings["Ava"]["Spider-Verse"] = 5

If your teen is newer to Python, this is a good moment to practice:

• creating dictionaries
• checking if keys exist
• writing small helper functions

Step 3: Compute “similarity” between users

We need a way to measure how similar two people’s tastes are.

A beginner-friendly method is cosine similarity over common rated items:

• Treat each user’s ratings as a vector
• Compare angle between vectors
• Output ranges from 0 (not similar) to 1 (very similar) for non-negative ratings

You can also use a simpler method like “average absolute difference,” but cosine similarity tends to behave nicely.

Step 4: Recommend items the teen hasn’t rated

For the teen (target user), we:

1. Find other users who are similar
2. For items the target user hasn’t rated, compute a weighted score:
   • higher weight from more similar users
3. Sort and return the top N

This is the “aha” moment: your teen will see recommendations change as they adjust ratings.

Step 5: Use this starter code (minimal dependencies)

This code runs in any basic Python environment (no pandas required). If you want, you can paste it into a notebook or a simple .py file.

import math

# Example dataset: ratings[user][item] = rating
ratings = {
    "Ava": {"Spider-Verse": 5, "Dune": 3, "Mario Odyssey": 4},
    "Ben": {"Spider-Verse": 4, "Dune": 5, "Hades": 5},
    "Cara": {"Spider-Verse": 5, "Mario Odyssey": 5, "Hades": 4},
    "Dev": {"Dune": 4, "Hades": 5, "Celeste": 4}
}


def cosine_similarity(u_ratings, v_ratings):
    # Find items both users rated
    common = set(u_ratings) & set(v_ratings)
    if not common:
        return 0.0

    dot = sum(u_ratings[i] * v_ratings[i] for i in common)
    norm_u = math.sqrt(sum(u_ratings[i] ** 2 for i in common))
    norm_v = math.sqrt(sum(v_ratings[i] ** 2 for i in common))

    if norm_u == 0 or norm_v == 0:
        return 0.0

    return dot / (norm_u * norm_v)


def recommend_for_user(target_user, ratings, top_n=3):
    target_ratings = ratings[target_user]

    # Similarities to other users
    sims = {}
    for other_user, other_ratings in ratings.items():
        if other_user == target_user:
            continue
        sims[other_user] = cosine_similarity(target_ratings, other_ratings)

    # Score candidate items not rated by target
    scores = {}
    sim_sums = {}

    for other_user, sim in sims.items():
        if sim <= 0:
            continue
        for item, r in ratings[other_user].items():
            if item in target_ratings:
                continue
            scores[item] = scores.get(item, 0) + sim * r
            sim_sums[item] = sim_sums.get(item, 0) + sim

    # Normalize scores
    ranked = []
    for item in scores:
        ranked.append((item, scores[item] / sim_sums[item]))

    ranked.sort(key=lambda x: x[1], reverse=True)
    return ranked[:top_n]


print("Recommendations for Ava:")
for item, score in recommend_for_user("Ava", ratings, top_n=5):
    print(f"  {item}: {score:.2f}")

What to do after it runs:

• Change one rating (like Ava’s rating for “Dune”) and rerun.
• Add a new item and have everyone rate it.
• Add a brand-new user and see how it affects results.

Step 6: Make it a real “project,” not just a script

Parents often ask what turns a quick build into something “portfolio-worthy.” Here’s a practical checklist your teen can implement over a weekend.

• Input/output
  • Ask for the target user name
  • Print top 5 recommendations
  • Optionally explain “why” (which similar users influenced the result)
• Data storage
  • Save ratings to a CSV file
  • Load ratings when the program starts
• Basic evaluation
  • Hide one known rating and see if the system predicts it reasonably

Here’s a simple “why” explanation idea: for each recommended item, print the top 2 users who contributed most (highest sim * rating). Teens love seeing the logic.

Common pitfalls (and how to turn them into learning moments)

Recommendation systems are also a gentle introduction to the messiness of real data.

Pitfall 1: “It recommends nothing!”

Usually caused by no overlap in rated items.

Fix together:

• Make sure users rate some of the same items
• Start with a “core set” of 4–5 items everyone rates

Pitfall 2: The “popular items” dominate

If one item is rated by everyone, it can show up too often.

What to try:

• Add more niche items
• Add a rule: don’t recommend items with fewer than 2 ratings (in bigger datasets)

Pitfall 3: Bias and filter bubbles

If the teen only rates one genre, the system will keep feeding that genre.

Discussion prompts for a great parent-teen conversation:

• Should recommenders sometimes include “wildcards”?
• What happens if ratings reflect peer pressure?
• Why do platforms care about watch time vs. satisfaction?

Pitfall 4: Privacy

Even a small family dataset is a good time to practice good habits.

• Don’t use real full names if sharing publicly
• If using classmates, ask permission before collecting ratings
• Keep it local (a file on your computer) instead of posting raw data online

Next Steps: Turn this into a high school-ready AI project

Once your teen has the basic recommender working, these upgrades make it a standout ai project ideas high school entry without making it overwhelming.

• Add item categories (hybrid recommender)
  • Store genres/tags for each item
  • Combine collaborative score + content-based similarity
• Use pandas + a CSV ratings file
  • Great practice for “real” data workflows
• Add a tiny command-line menu
  • “Rate an item”
  • “Get recommendations”
  • “Show similar users”
• Make it a mini app
  • A simple web interface (Flask) or a notebook with buttons
• Write a short project report (one page)
  • Problem statement
  • Data you collected
  • Method (cosine similarity)
  • 2–3 screenshots of results
  • What you’d improve next

If you want the project to feel extra meaningful, let your teen choose a focus like:

• “Recommendations for co-op games my friends will actually play”
• “Books I’ll like after finishing a fantasy series”
• “Movies for family night that match everyone’s tastes”

That’s the secret to a great recommendation system project for students: it’s personal, testable, and easy to iterate.