Teen Project: Build a Simple Recommender System in Python (No Advanced Math)

Why a recommender system is a perfect teen-friendly AI project

If your teen has ever said, “How does Netflix know what I’ll like?” or “Why does Spotify keep recommending the same vibe?”—that curiosity is the start of a real-world AI build.

A recommender system is an AI feature that suggests items a person might like (movies, books, songs, games, even snacks). The best part: a beginner version doesn’t require advanced math. High schoolers can build a working recommendation engine with:

• Basic Python (lists, dictionaries, loops)
• Simple “similarity” logic (counting overlaps)
• A small dataset of ratings

This makes it an ideal machine learning project for beginners teens because it feels like “real AI” without needing calculus or heavy statistics. It’s also a great portfolio piece for teens ages 15–17: clear goal, measurable results, and easy ways to extend.

In this post, we’ll build a recommender system project for high school students that’s simple, explainable, and surprisingly powerful.

Project overview: What your teen will build (and what they’ll learn)

We’re going to create a mini “recommendation engine” that can suggest movies (or games/books) to a user based on what similar users liked.

Two common approaches exist:

• Content-based: recommend items similar to items you liked (needs item features like genre/tags)
• Collaborative filtering: recommend items liked by people similar to you (needs user ratings)

For a first project, collaborative filtering is the most fun because it mimics real-world systems and uses intuitive logic: “people with similar tastes might like similar things.”

What you’ll learn (skills that actually transfer)

• Turning a real problem into a data structure (users → items → ratings)
• Writing functions to score similarity
• Generating ranked recommendations
• Evaluating results and improving the model

What you’ll need

• Python 3.10+ (or any recent version)
• Any code editor (VS Code is great)
• 30–60 minutes to build the first version

Here’s a practical plan you can follow:

Step	What to do	Time	Output you can show
1	Choose a theme + items (movies, games, books)	10 min	A short list of items (10–20)
2	Collect ratings from 5–10 people	20 min	A small dataset (dictionary/CSV)
3	Code similarity + recommendations	30–45 min	Recommendations printed for each user
4	Test and tune	15–30 min	Better recommendations + insights

Tip for parents: if your teen isn’t ready to ask friends for ratings, they can invent a dataset to learn the mechanics—then replace it later with real ratings.

Build it: A simple Python recommendation engine (step-by-step)

Below is a beginner-friendly python recommendation engine tutorial simple enough for teens, but structured like a real project.

1) Create a tiny ratings dataset

We’ll represent ratings as a nested dictionary:

• Top level: user name
• Inside: item name → rating (1–5)

ratings = {
    "Ava": {"Inception": 5, "Frozen": 2, "Spider-Man": 4, "Dune": 5},
    "Ben": {"Inception": 4, "Frozen": 1, "Spider-Man": 5, "Moana": 2},
    "Chloe": {"Inception": 2, "Frozen": 5, "Moana": 5, "Encanto": 4},
    "Diego": {"Inception": 5, "Dune": 4, "Spider-Man": 4, "Interstellar": 5},
    "Ella": {"Frozen": 4, "Moana": 5, "Encanto": 5, "Spider-Man": 2}
}

2) Define a simple similarity score (no advanced math)

We’ll compare two users by looking at items both have rated, and scoring how close their ratings are.

This version gives a higher score when ratings are similar:

def similarity(user1, user2, ratings):
    items1 = ratings[user1]
    items2 = ratings[user2]

    shared_items = set(items1.keys()) & set(items2.keys())
    if not shared_items:
        return 0

    # Start with 0, add points for each shared rating
    score = 0
    for item in shared_items:
        diff = abs(items1[item] - items2[item])  # 0 to 4
        score += (4 - diff)  # 4 means identical, 0 means very different

    # Average it so users with more overlap aren't unfairly favored
    return score / len(shared_items)

Why this is teen-friendly: it’s just subtraction, absolute value, and averaging.

3) Find the most similar users (“neighbors”)

Now we rank other users by similarity:

def nearest_neighbors(target_user, ratings, k=2):
    scores = []
    for other_user in ratings:
        if other_user == target_user:
            continue
        sim = similarity(target_user, other_user, ratings)
        scores.append((other_user, sim))

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

4) Generate recommendations

We’ll recommend items the target user hasn’t rated yet, based on what neighbors liked.

def recommend(target_user, ratings, k=2):
    neighbors = nearest_neighbors(target_user, ratings, k=k)
    target_items = ratings[target_user]

    # candidate item -> weighted score sum
    totals = {}
    sim_sums = {}

    for neighbor, sim in neighbors:
        for item, rating in ratings[neighbor].items():
            if item in target_items:
                continue  # already rated

            totals[item] = totals.get(item, 0) + rating * sim
            sim_sums[item] = sim_sums.get(item, 0) + sim

    # Convert weighted totals into predicted ratings
    predictions = []
    for item in totals:
        predicted = totals[item] / sim_sums[item]
        predictions.append((item, predicted))

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

5) Try it out

print("Neighbors for Ava:", nearest_neighbors("Ava", ratings, k=2))
print("Recommendations for Ava:")
for item, score in recommend("Ava", ratings, k=2):
    print(f"- {item}: predicted {score:.2f}")

If your dataset has enough overlap, your teen should see sensible results like “Interstellar” recommended to someone who loved “Inception” and “Dune.”

Quick debugging checklist (common teen gotchas)

• If recommendations are empty: users don’t share enough rated items
• If similarity is always 0: there are no shared items between users
• If one person rated only one movie: ask them to rate at least 5

Make it feel “real”: Data collection, testing, and project upgrades

A recommender system becomes impressive when it’s backed by a small but real dataset and a clear test.

Collect ratings in a simple way

Your teen can gather data without fancy tools:

• Use a Google Form with a 1–5 scale for 10–20 items
• Ask family or friends to rate at least 5 items
• Export to CSV and load it into Python later

Parents: this is also a nice moment to practice digital responsibility—no need to collect full names, emails, or personal details. Nicknames are fine.

Evaluate whether it works (simple, not “research paper”)

Have your teen run these checks:

• Pick one user, hide one of their ratings (pretend it’s unknown)
• Generate recommendations
• See if the hidden item appears near the top

They can repeat this for 3–5 hidden ratings and track how often the system “guesses” well.

Upgrade ideas (great for portfolios)

These are perfect ai project ideas for students 15-17 because each one adds real engineering value:

• Add a “minimum overlap” rule: only compare users who share at least 2–3 rated items
• Allow thumbs-up / thumbs-down instead of 1–5 ratings (simpler UI)
• Explain the recommendation: “Recommended because Diego (similarity 3.5) rated it 5”
• Turn it into a mini-app: simple command-line prompts, or a basic web app later
• Compare strategies: user-based vs. item-based (advanced but doable)

Common mistakes (and how to coach through them)

• Mistake: too few items → Add more items or require at least 5 ratings per user.
• Mistake: everybody rates everything → That’s okay, but recommendations are more interesting when some items are missing.
• Mistake: confusing “accuracy” → This isn’t a perfect predictor; it’s a ranking tool. “Good” means the top 3 suggestions are reasonable.

Next Steps: A simple plan to finish and share the project

To turn this into a complete, shareable project (the kind schools and programs love), follow this checklist.

• Day 1 (45–60 min): Build the core model

  • Set up the ratings dictionary
  • Implement similarity(), nearest_neighbors(), and recommend()
  • Print recommendations for 2–3 users

• Day 2 (30–60 min): Make it real

  • Collect ratings from 5–10 people (or expand the dataset)
  • Save the dataset in a CSV and load it in Python

• Day 3 (30–60 min): Improve and present

  • Add “explanations” for each recommendation
  • Write a short README:
    • What problem you solved
    • How to run the code
    • What you’d improve next

If your teen wants to go one step further, encourage them to film a 60-second demo: “Here’s my recommendation engine. Here’s how it finds similar users. Here are the results.” That kind of communication skill is a hidden superpower in tech.

If you’re looking for a guided path, Intellect Council projects can help teens practice these exact steps—building real systems, testing them, and learning the ‘why’ behind the code in a way that stays fun and doable.