How to Build a Recommendation System Without Code

You can build a recommendation system in TensorTurn by framing it as a supervised ranking problem: upload your interaction history (which users saw or bought which items), describe the goal in chat, and it trains a propensity model — usually XGBoost or scikit-learn — that scores how likely each user is to engage with each item, then deploys a /predict API you call for candidate items and sort by score. TensorTurn is not a turnkey collaborative-filtering engine with pre-built user and item embeddings; instead it builds the ranking model that most production recommenders actually use to re-rank candidates.

How recommendation becomes a model you can train

A recommender is fundamentally a ranking problem: given a user and a candidate item (plus context), predict a relevance score, then sort the items by that score. In practice you train a supervised model on logged interactions where the label is whether the user engaged — clicked, added to cart, purchased or watched. TensorTurn builds exactly this scoring model. You supply the candidate items to score (for example, everything in a category, recently added items, or a popularity shortlist) and the model orders them per user. Be clear-eyed about the boundary: it does not do candidate generation or embedding-based retrieval for you.

What data you need

• One row per user-item interaction, with a label: 1 if the user engaged (clicked, added to cart, purchased, watched) and 0 if the item was shown but ignored.
• User features: attributes and behavior aggregates such as days since signup, past purchase count, favorite category, average order value.
• Item features: category, price, brand, days since launch, overall popularity.
• Context features: time of day, day of week, device, page or placement.
• Negative examples — items the user saw but did not engage with — so the model learns to separate relevant from irrelevant, not just memorize positives.
• Explicit ratings (1-5 stars) also work if you would rather predict a rating than an engagement event.

How to build a recommendation model with TensorTurn (no code)

• Assemble one row per historical impression or interaction with an engagement label, and import it (CSV, Excel, zip or URL).
• Run the tabular health check for leakage, correlations, outliers and duplicates — leakage is the biggest risk here.
• In chat: 'Predict the engaged column (1 = purchased) from the user, item and context features, and rank items by score.'
• TensorTurn trains a gradient-boosted or scikit-learn classifier, self-heals broken cells, and reports ranking-friendly metrics.
• Review ROC-AUC (a direct proxy for ranking quality), PR-AUC and calibration.
• Deploy a /predict endpoint; at serving time, score each candidate item for a user and sort by the returned probability to produce the recommendations.

How it's evaluated

The most useful offline metric is ROC-AUC, which is literally the probability the model ranks a relevant item above an irrelevant one — exactly what a recommender needs. PR-AUC matters because positives are rare (most impressions are not clicked). Two honest caveats: offline metrics only approximate real recommendation quality, and the only trustworthy test of a recommender is an online A/B test on live traffic, because offline data cannot show how users react to new suggestions. And leakage is dangerously easy — a feature like 'purchased_later' or an item field only known after the interaction will make offline scores look perfect and fail in production. Trust the health check.

Honest limits

TensorTurn builds the ranking and scoring model, not the entire recommendation stack. You still handle candidate generation (which items to score), cold start (new users and items have thin features, so lean on item and context signals), and freshness (retrain as behavior drifts). For catalogs of millions of items you would not score every item on every request — score a shortlisted candidate set and let the model order it.

Deploy as an API

Publish an authenticated /predict endpoint on Modal with a SHA-256-hashed Bearer key, per-call logging and scale-to-zero. At request time, send the user's features paired with each candidate item, take the returned scores, and sort to produce the ranked recommendations. The playground gives cURL, JavaScript, Python and Rust snippets to wire it into your app.