Do you ever stare at a food label and wonder, “Is this actually good for me?” You’re not alone. Enter food scoring, a quick way to gauge nutrition at a glance. You’ve seen it before: those red, amber, and green traffic lights on packaging. Simple, effective, but limited.
In the UK, this system is based on nutrient thresholds per 100 grams. It’s a decent guide for snap decisions at the supermarket, but if we’re being honest, it barely scratches the surface.
What if we could go further? A single traffic light system treats everyone the same. But you aren’t the same as everyone else. Maybe you work out daily. Maybe you sit at a desk all day. Maybe you’re training for a marathon. Maybe, like me, you really, really love cheese. Instead of a generic label, what if we had a personalised score? A system that adapts to you: your goals, your body, your preferences.
Let’s dig into how that might work.
What goes into a food score?
Let’s get one thing straight: a food score isn’t some mystical number pulled out of thin air, it’s a simplified presentation of a food’s nutrition. Often, but not always, it’s tailored to you to help you make more informed choices.
Let’s break that down.
A food score is simplified because food is complicated. It’s a swirling miasma of macronutrients, micronutrients, vitamins, and minerals. Some of these have a profound impact on health, others not so much. Tracking all of it? Not realistic. That’s where models come in.
Models are smart shortcuts. They help us make sense of complexity without drowning in details. A good model does three things:
- Generalises findings, so we’re not stuck analysing individual cases.
- Simplifies complexity, so we can make quick decisions.
- Improves communication, because few people have the time and inclination to read a 50-page report before choosing their lunch.
But here’s the catch: a food score isn’t just about food. It’s about you. Your body isn’t a spreadsheet. It’s a dynamic system influenced by metabolism, genetics, activity levels, and your gut microbiome. Two people can eat the same meal and have wildly different responses. One might feel energised. The other? Bloated and lethargic.
If a food score doesn’t account for individuality, it’s missing the mark. But as we’ll see, personalisation brings its own challenges. More on that later. For now, let’s explore what you need for even the simplest food scoring model: data.
Nutrition data
Before we can score anything, we need data, a lot of it. You might think this means scraping websites, scanning barcodes, or manually typing out tables of nutrient values. Thankfully, someone else has already done that hard work.
Here are two of the most comprehensive food databases available.
- CoFID (Composition of Foods Integrated Dataset): used in the UK
- USDA Foods Database: the US equivalent
Let’s take a closer look at CoFID, specifically, its macronutrient data: things like protein, carbohydrates, fats, and energy per 100 grams — the core building blocks of nutrition.
This post has an accompanying notebook. Check it out for the full code.
In the notebook, I import the data and clean it up by renaming some columns, filling in some missing values (though not all), and indexing the table by the food name. The result? A macronutrient dataset showing breakdown per 100g.
| food_name | kcal_100g | protein_100g | carb_100g | fat_100g | fibre_100g |
|---|---|---|---|---|---|
| Ackee, canned, drained | 151 | 2.9 | 0.8 | 15.2 | |
| Agar, dried | 16 | 1.3 | 1.2 | ||
| Agar, dried, soaked and drained | 2 | 0.2 | 0.1 | ||
| Alfalfa sprouts, raw | 24 | 4 | 0.4 | 0.7 | |
| Allspice, ground | 6.1 | 8.7 | |||
| Almonds, flaked and ground | 612 | 21.1 | 6.9 | 55.8 | |
| Almonds, toasted | 579 | 21 | 5.9 | 52.5 | 10.9 |
| Almonds, weighed with shells | 205 | 7.8 | 1.9 | 18.5 | 4.6 |
| Almonds, whole kernels | 554 | 21.2 | 5.3 | 49.9 | 12.5 |
| Amaranth leaves, boiled in unsalted water | 16 | 3 | 0.3 | 0.3 |
Notice a few things?
- Food names are long and unintuitive.
- Some foods have missing data, especially fibre values.
These quirks are exactly why data cleaning matters. Raw nutrition data is rarely perfect. If we don’t preprocess it, we risk building a scoring system on incomplete or misleading numbers, even before we’ve built a model! We’ll address these issues shortly, but first, let’s look at an example scoring model.
Building a scoring model
This is the fun part: turning raw nutrition data into an actual food score.
There are many ways to do this. Before we pick one, let’s ask a simple question:
What are we trying to optimise?
- A balanced macronutrient ratio?
- A calorie-controlled diet?
- A low-carb, high-protein approach?
- Something else entirely?
Each goal demands a different scoring method. For now, let’s start with something simple: a macronutrient balance model.
Defining the “ideal” balance
A common macronutrient guideline suggests a 15/50/35 split between protein, carbohydrates, and fats (National Library of Medicine):
- 15% protein
- 50% carbohydrates
- 35% fats
That means for every 15 grams of protein, we should aim for 50 grams of carbs and 35 grams of fat. While this is a common guideline, it’s by no means a universal rule. Different diets adjust these ratios significantly.
Let’s translate that into daily intake based on a 2,500 kcal target:
| Macronutrient | % daily calories | Calories | Target |
|---|---|---|---|
| Protein | 15% | 4 kcal/g | 94g |
| Carbs | 50% | 4 kcal/g | 313g |
| Fat | 35% | 9 kcal/g | 97g |
We eat multiple meals per day, so let’s divide those by three meals:
| Macronutrient | Ideal per meal |
|---|---|
| Protein | ~31g |
| Carbs | ~104g |
| Fat | ~32g |
Now, let’s create a meal to score. I suggest one of my favourite buddha bowls.
| Ingredient | Amount (g) |
|---|---|
| Pork | 150g |
| Pearl barley | 80g |
| Cucumber | 80g |
| Avocado | 70g |
| Tomatoes | 40g |
| Spring onions | 20g |
| Sweet potato | 160g |
| Cheese | 35g |
| Mayonnaise | 15g |
| Honey | 8g |
| Lemon juice | 5g |
| Mustard | 5g |
| Oil | 10g |
Scoring the meal
We’ll measure deviation: how far each macronutrient strays from the target. The closer, the better. A perfect score is 1.0, an exact match, and a score closer to 0 means it’s way off.
Check out the accompanying notebook for the full model code.
Running it through our model, our sample meal scores 0.76. Not bad!
Tweaking the model
What happens if we swap pork for chicken?
Running our model again with the new meal, our new score is 0.71. Slightly worse. Why? Because pork has more fat, and our model favours meals that stick to the 15/50/35 ratio. This highlights an important takeaway:
Your scoring model directly influences your food choices.
If we change the model’s priorities (e.g., more protein, less fat), we’d get different meal scores. That’s why picking the right model for your goals matters.
The real-world process
So, we’ve built a simple model. But real-world food scoring systems? They’re a different beast. Here’s how the process often works, step by step:
1. Data cleaning: Making sense of messy data
Remember the issues with our macronutrient data set? Nutrition data is messy. Food names are inconsistent. Some values are missing. Different countries have different labelling laws. If we just take raw data at face value, we’ll get garbage scores, so before anything else, we need to:
- Standardise food names (because “Almonds, whole kernels” and “Whole almonds” should be the same thing).
- Fill in missing values (or, if we can’t, decide how to handle them).
2. Normalisation: Finding commonality in the data
Even after cleaning, foods can’t be compared properly until they’re on the same scale.
For example:
- One food lists protein per serving.
- Another lists protein per 100 grams.
- Another lists protein per whole package.
See the problem? This inconsistency is a problem for meaningful comparisons. Before we can score anything, we need to bring everything back to a shared baseline. Usually, that means converting everything to per 100g or per kilocalorie.
3. Weighting and scoring: Deciding what matters
Once the data is clean and standardised, we decide how to score a food.
But we need to be careful: this is where bias can sneak in. Let’s say we build a model that prioritises low sugar. That’s fine, unless it also penalises high-fat foods like nuts and avocados, which are, in fact, very nutritious. Suddenly, our system says that Pepsi Max is “healthier” than almonds. Not ideal.
That’s why weighting matters. A good scoring model:
- Prioritises what’s important (not just what’s easy to measure).
- Accounts for trade-offs (because no single nutrient defines a food’s value).
- Reflects real dietary needs (not just trends).
And often, it even needs to fill in the gaps.
4. Handling missing data
Take fibre, for example. In our macronutrient dataset, most foods were missing it.
We have three choices:
- Ignore the food (but that’s wasteful and leads to a subpar user experience).
- Assume the missing value is zero (which is usually wrong).
- Estimate it based on similar foods.
Option 3 is the smartest. One method is to find foods that have similar nutrition profiles using a Euclidean distance, a metric that finds similar foods based on their macronutrient profile. By identifying the closest match in terms of protein, carbs, and fat content, we can infer a reasonable fibre value and then fill it in. It’s not perfect, but it’s better than assuming zero. And this trick can be applied to all sorts of missing values.
We explore how to do this in the accompanying notebook .
5. Feature selection: Less is more
More data isn’t always better. A scoring model that tries to account for 50 different nutrients will be unusable. Instead, we need to focus on the most important factors.
For example, depending on the goal:
- A general health score might focus on fibre, protein, and saturated fat.
- A weight-loss score might prioritise calories and sugar content.
- A diabetes-friendly score might look at glycemic index and carbohydrates.
Pick too many features? The score becomes meaningless. Pick too few? The score becomes misleading. It’s all about balance.
6. Final scoring: Behind the numbers
Once everything is cleaned, normalised, weighted, and processed, we can finally generate a score.
A simple approach is distance from the ideal like we saw in our earlier macronutrient model and used in the accompanying notebook . More complex models might use:
- Regression models to predict real-world health impacts.
- Machine learning to adapt scores based on user behaviour.
- Composite scoring to weigh multiple factors into one final number.
Model ethics: Transparency and intent
But here’s another catch: the more personalised and complex a food score gets, the harder it is to explain.
If a score is based on 30 different factors, how do you know why a food got a certain rating? If users don’t understand the reasoning, they might blindly trust or ignore the score.
Food scores seem harmless. But a bad model? It can do real harm. Here are some of the biggest ethical pitfalls:
1. Oversimplification: “Healthy” vs. “unhealthy”
Scoring food is not the same as scoring an algebra test. If a system oversimplifies, it can mislead users. To reiterate an example from earlier:
- “High-fat foods are bad”, so almonds get a low score.
- “Low-calorie foods are good”, so diet soda gets a high score.
Reality? Almonds are packed with nutrients. Diet soda is diet soda.
A good model doesn’t just spit out a score, it provides context.
2. Data bias: Who decides what’s “good” food?
Most food databases are built for Western diets. That means:
- Many Asian, African, or Latin American foods are missing.
- Scores often reflect Western nutrition priorities (like low-fat, low-carb).
If the data set is biased, the scores will be biased, so we need diverse food data sets and user input to improve accuracy.
3. Psychological impact: The danger of “scoring” food
Food scoring can influence behaviour, for better or worse. Done right, it helps people make smarter choices. Done wrong, it encourages obsessive tracking and disordered eating.
Some risks:
- Moralising food, turning eating into a game of “good” vs. “bad.”
- Over-restriction, where users might avoid foods they should be eating.
- Algorithm dependency — letting a score decide what you eat, instead of personal judgment.
Food scores are powerful, but imperfect
Food scoring is only as good as the logic behind it, and it’s not magic. It’s data, assumptions, and algorithms all wrapped into a system that tries to help people make better choices. But, like all models, it’s flawed. A food score is not an absolute truth. It’s a tool, and it’s only useful if you know how to use it. No single model captures the full complexity of nutrition.
So next time you see a food score, ask yourself:
- What’s actually being measured?
- What’s missing?
- Who decided what matters?
Be an informed consumer. Look at ingredient lists, not just scores. Use scores as a guideline, not a rule. Question models that oversimplify nutrition. Trust the numbers, but trust yourself more.