Teen Project Sprint: Build a Simple Recommendation System in Python

A weekend project that feels like “real AI” (and teaches real skills)

Recommendation engines power Netflix, Spotify, YouTube, and Amazon. The cool part? Your teen can build a simple version in a single project sprint—no advanced math required.

This post is a practical recommendation system project for students (ages 14–17) that fits into a weekend. It’s one of the best machine learning project ideas for teens because it connects coding to something personal: movies, books, or music they already love.

We’ll build a beginner-friendly “people who liked this also liked that” system using Python. It’s not a full deep-learning pipeline—and that’s a feature, not a bug. Your teen will learn the core building blocks behind many real recommenders:

• Turning messy preferences into clean data
• Computing similarity (how close two items are)
• Generating ranked recommendations
• Testing, debugging, and improving results

If you’re a parent wondering, “Is this too hard?”—it’s totally doable with guidance and a clear checklist.

Pick your recommender type: 3 options (choose 1)

A good project sprint has one clear choice. Have your teen pick the domain they’ll enjoy most:

• Movies: easiest to find public datasets (MovieLens) and it’s instantly relatable
• Books: great for readers; can use Goodreads-style ratings data or a custom family dataset
• Music: fun, but public rating data can be trickier (still doable with custom likes)

For a first build, I recommend movies because the datasets and examples are plentiful, and the results are easy to “feel” when you test.

Here’s the approach we’ll use:

• Item-based collaborative filtering: recommend items similar to the ones a user liked.
• We’ll measure similarity with a simple metric (cosine similarity).

This keeps the project beginner-friendly while still qualifying as a high school AI project recommendation engine.

Project sprint plan (so it actually gets finished)

Break the work into short, clear steps. This table is designed so a teen can check boxes and feel progress.

Sprint Step	Time (est.)	What you build	“Done” looks like	Common snag + fix
1. Set up	30–45 min	Python environment + libraries	Code runs without errors	Package errors → use a fresh venv + pip install -U
2. Load data	45–60 min	CSV read + basic cleanup	You can print rows + counts	Wrong file path → put CSV in same folder
3. Create user-item matrix	60–90 min	Pivot table (users × items)	Matrix has users as rows, movies as columns	Missing values → fill with 0
4. Compute similarity	45–60 min	Similarity between movies	You can list “most similar to Toy Story”	Too slow → start with a smaller dataset
5. Recommend for a user	60–90 min	Top-N movie list	Output looks sensible	Recommends already-seen items → filter them out
6. Improve + present	60–120 min	Better results + mini write-up	3 screenshots + 5–8 sentence explanation	Vague explanation → describe inputs, method, output

Build it: a beginner Python recommendation system tutorial (with clear code)

This is a compact, beginner-friendly version. It uses MovieLens “small” style data: one file of ratings.

What you need

• Python 3.10+
• Libraries: pandas, numpy, scikit-learn

Install:

• pip install pandas numpy scikit-learn

Step 1: Load ratings data

Your data should have at least:

• userId (a number)
• movieId (a number)
• rating (for example 1–5)

import pandas as pd

ratings = pd.read_csv("ratings.csv")
print(ratings.head())
print(ratings.shape)

If you also have movie titles (often in movies.csv), load them too:

movies = pd.read_csv("movies.csv")  # movieId, title

Step 2: Create a user-item matrix

This turns the table into something the computer can compare.

user_item = ratings.pivot_table(
    index="userId",
    columns="movieId",
    values="rating",
    fill_value=0
)
print(user_item.shape)

Step 3: Compute item-to-item similarity

We’ll compute similarity between movie columns.

from sklearn.metrics.pairwise import cosine_similarity

# Transpose so we compare movies by their rating patterns across users
item_vectors = user_item.T

similarity_matrix = cosine_similarity(item_vectors)

# Put it in a DataFrame for easy lookups
item_similarity = pd.DataFrame(
    similarity_matrix,
    index=item_vectors.index,
    columns=item_vectors.index
)

Step 4: Make a “similar movies” function

This is a motivating early win: type a movie and get similar ones.

def similar_movies(movie_id, top_n=10):
    sims = item_similarity[movie_id].sort_values(ascending=False)
    # first one is the movie itself (similarity 1.0)
    return sims.iloc[1:top_n+1]

If you have titles:

def movie_title(movie_id):
    row = movies[movies["movieId"] == movie_id]
    return row["title"].values[0] if len(row) else str(movie_id)

example_id = ratings["movieId"].iloc[0]
print("Because you liked:", movie_title(example_id))
print(similar_movies(example_id, top_n=5).index.map(movie_title))

Step 5: Recommend for a specific user

Now we generate personalized recommendations.

Idea:

• Find what the user rated highly
• For each liked movie, add points to similar movies
• Rank the results
• Remove movies the user already rated

import numpy as np

def recommend_for_user(user_id, top_n=10, min_rating=4.0):
    # User's ratings
    user_ratings = ratings[ratings["userId"] == user_id]

    liked = user_ratings[user_ratings["rating"] >= min_rating]["movieId"].tolist()
    if not liked:
        return []

    # Score candidates
    scores = pd.Series(dtype=float)
    for m in liked:
        sims = item_similarity[m]
        scores = scores.add(sims, fill_value=0)

    # Remove already seen
    seen = set(user_ratings["movieId"].tolist())
    scores = scores.drop(labels=list(seen), errors="ignore")

    # Sort and return top
    top_movie_ids = scores.sort_values(ascending=False).head(top_n).index.tolist()
    return top_movie_ids

user_id = ratings["userId"].iloc[0]
recs = recommend_for_user(user_id, top_n=10)
print("Recommendations:")
for mid in recs:
    print("-", movie_title(mid))

That’s a working recommender. Your teen can now say they built a recommendation engine using collaborative filtering.

Make it feel like a polished high school AI project (not just a script)

The difference between “I coded something” and “I built a project” is testing, presentation, and one or two improvements.

Easy upgrades that make results better

Pick 1–2 of these—don’t try to do everything.

• Use weighted scores: multiply similarity by the user’s rating (a 5-star like counts more than a 4-star like).
• Filter out unpopular items: ignore movies with too few ratings (reduces weird recommendations).
• Add a “cold start” option: if a user has no ratings, ask them to pick 3 favorites first.
• Add a simple evaluation: hide one liked movie and see if the system recommends it.

Here’s a simple “popular items only” filter:

movie_rating_counts = ratings.groupby("movieId").size()
popular_movies = set(movie_rating_counts[movie_rating_counts >= 50].index)

# When scoring, keep only popular candidates
# (apply after computing scores)
# scores = scores[scores.index.isin(popular_movies)]

What parents can look for (great signs of real learning)

• They can explain what the input data represents (users, items, ratings)
• They can describe “similarity” in plain language
• They test with multiple users and notice surprising results
• They can name one limitation (for example: “new movies with no ratings won’t get recommended”)

A mini project write-up template (copy/paste)

Encourage a short write-up to build communication skills (a big part of AI work):

• Goal: Build a recommendation engine for movies/books/music.
• Data: Source + number of rows + what each column means.
• Method: Item-based collaborative filtering with cosine similarity.
• How recommendations are generated: Sum similarity scores from items the user liked.
• Results: 1–2 example users and their top recommendations.
• Limitations: Cold start, popularity bias, sparse ratings.
• Next improvement: One specific upgrade.

This turns the code into a portfolio-ready high school ai project recommendation engine.

Next Steps: How to get started today (and finish this sprint)

To keep momentum high, aim for a “first working version” before adding upgrades.

Step-by-step checklist

• Download a dataset (MovieLens recommended) or create your own CSV with columns: userId, itemId, rating
• Install libraries: pandas, numpy, scikit-learn
• Build:
  • user-item matrix
  • similarity matrix
  • recommend_for_user() function
• Test with 3 different users
• Add 1 improvement (popular filter or weighted scores)
• Create a 1-page project summary + 2 screenshots of output

If your teen is using Intellect Council

Turn this into a structured sprint:

• Day 1: Data + matrix + similarity
• Day 2: Recommendations + improvements + write-up

If you’d like, share what domain your teen chose (movies, books, or music) and whether they have a dataset already—I can suggest the simplest data format and one upgrade that fits their skill level.