Allergen Management for Multi-Ingredient Recipes and Sub-Recipes
Software handles allergen management for multi-ingredient recipes properly only when it holds allergens at the ingredient level and inherits them automatically into every recipe and sub-recipe that uses that ingredient. That one design decision is what makes a sauce inside a pie inside a meal deal declare correctly. FoodCore works this way: allergens are set once on an ingredient, then cascade upward through unlimited levels of sub-recipe into finished products, labels and the allergen matrix. Anything that asks you to re-declare allergens on each recipe by hand will drift out of date the first time a supplier reformulates.
The short answer, in more detail
Most allergen tools handle a simple product perfectly well. A loaf has flour, water, yeast and salt, and declaring gluten against it is not hard. Systems fall over when the product is built from other products — when a sauce is an ingredient, when a bought-in paste hides sesame in the supplier's own formulation, when a meal deal is assembled from components that have components of their own.
There are only two ways to model allergens in software, and they behave very differently at scale:
- Recipe-level allergens. You type the allergen list onto each finished recipe. Fast to set up, and wrong within weeks. Nothing links the ingredient to the products containing it, so a reformulation means remembering every affected product and editing each one.
- Ingredient-level allergens with inheritance. You declare allergens once, on the ingredient. Every recipe and sub-recipe using it inherits the declaration automatically, at every depth. One edit updates everything downstream.
For a multi-ingredient range, only the second model is defensible. If you are still choosing between platforms in general, our wider comparison of allergen management software covers price and features; this piece is specifically about the nesting problem.
Why multi-ingredient products are where it breaks
The failure is rarely dramatic. Nobody forgets that a cake contains eggs. What happens instead is quiet. A supplier changes the anti-caking agent in a stock powder and adds a milk derivative. The powder is used in a gravy; the gravy in four pies; two of those pies are sold as PPDS with printed labels. The person who receives the updated specification is not the person who wrote the pie recipes, and the link between the powder and the pies exists nowhere except in someone's memory.
A spreadsheet with one row per product encourages you to treat allergens as a property of the product. They are not. Allergens are a property of the ingredients; the declaration is a consequence. Any system storing the consequence rather than the cause diverges from reality once components are shared.
The cascade: a sauce inside a pie inside a meal deal
A worked example. An in-house spice blend contains mustard powder. The blend goes into a marinade, the marinade into a chicken filling, the filling into a pie, and the pie is packed with a salad and a dressing and sold as a meal deal. That is five levels, and mustard — one of the 14 allergens that must be declared under UK law — is present in the finished item.
For the declaration to be right, the allergen has to travel up all five levels without anyone re-typing it, and back down again: reformulate the blend to remove the mustard and the meal deal must change too, without anyone opening the meal deal record.
Test it with your worst recipe, not your simplest. Vendors demo a two-ingredient product because it always works. Ask to build the messiest thing you make — the one with a bought-in paste, an in-house sub-recipe and a component you buy from two suppliers. Change an allergen at the bottom and watch whether the top-level product updates on its own. If it does not, the tool is not suitable for a multi-ingredient range.
Compound ingredients: the allergen in your supplier's recipe
Nested in-house recipes are the visible half of the problem. The invisible half is compound ingredients — bought-in products that are themselves recipes. A curry paste, a stock concentrate, a chocolate coating, a bread mix. You buy one line item and receive a formulation you did not write and cannot inspect.
Two things follow. Your only source of truth is the supplier specification or the pack label, and that data has a shelf life: specifications are reissued and co-packers change without any visible difference in the pack. And the printed ingredients list may need to show a compound ingredient's own sub-ingredients, so you need the detail on file, not just a tick against 'contains milk'. Our guide to running an ingredient review cycle covers how often to re-check and how to evidence it.
Build a free allergen matrix for your range →'May contain' is not the same as an ingredient
Multi-ingredient products make it easy to blur two things UK law keeps apart. An allergen actually in the recipe is an ingredient: it belongs in the ingredients list, emphasised so it stands out from the surrounding text, even if it arrives in a tiny quantity from four levels down. A 'may contain' statement is a voluntary precautionary label describing an assessed cross-contamination risk you cannot design out. It is not a disclaimer and not a hedge against poor record-keeping.
In software terms these need to be two separate fields that inherit separately, so a precautionary warning on a sesame-adjacent flour propagates as a warning on the finished pie — without hardening into a declared ingredient, and without evaporating. For the underlying law, see our guide to the 14 major allergens.
What to demand of the software
Seven requirements, in order of importance. Without the first, the rest are cosmetic.
- Allergens held at ingredient level — a property of the ingredient record, never typed onto a recipe.
- Automatic inheritance through unlimited nesting, with no manual recalculation step.
- Recalculation in both directions: adding an allergen adds it downstream, removing one removes it.
- Declared allergens and precautionary statements kept separate.
- Sub-ingredient detail retained for compound ingredients, so a printed list can show what is inside a bought-in component.
- Labels generated from recipe data, not maintained as separate artwork that will eventually disagree with the recipe.
- A record of who changed an allergen and when, with the previous value visible.
Failure modes and how to prevent each
How FoodCore handles it
FoodCore holds allergens against the ingredient. Add an ingredient to a recipe and the recipe inherits its allergens; add a recipe as a sub-recipe and the parent inherits everything beneath it. All 14 UK allergens are covered, and the calculation reruns whenever anything in the chain changes, so a correction at the bottom reaches every product above it.
Labels. PPDS and Natasha's Law labels are generated from recipe data with allergens emphasised inside the ingredients list. Because the label comes from the recipe rather than a separate artwork file, it cannot quietly fall out of step with an amended recipe. Ingredients, allergens, recipes and label generation are all on Essentials at £25/month inc. VAT (£250/year).
Allergen matrix. A matrix across a whole menu — every product against every allergen, in one grid you can hand to a wholesale customer or an environmental health officer — is part of the menus and allergen matrix feature on Core, £65/month inc. VAT (£650/year).
Version history. On Growth (£40/month inc. VAT, £400/year) and above, every ingredient and recipe carries a timeline showing what changed, who changed it and when, with one-click restore to a previous version. When a declaration turns out to be wrong, the first two questions are always when it changed and who changed it, and the timeline answers both without anyone reconstructing it from memory.
Where the responsibility sits. FoodCore performs the inheritance calculation on the data you give it. It cannot verify that the allergens recorded against an ingredient match the current supplier specification, and it has no visibility of what happens on your bench. The legal duty for accurate allergen information rests with the food business operator, before and after you adopt any software. What good software changes is how much of that duty is manual, and how easily you can evidence having discharged it.
A setup order that avoids most of this
- Enter every ingredient first, compound ingredients included, with allergens from current supplier specifications and the specification date recorded.
- Build shared sub-recipes next — sauces, bases, blends, doughs — as recipes in their own right.
- Only then build finished products, referencing those sub-recipes rather than re-entering their components.
- Spot-check three finished products against their labels by hand, then put a compound-ingredient review cycle in the diary.
Frequently asked questions
Which food manufacturing software handles allergen management for multi-ingredient recipes?
Look for software that stores allergens against the ingredient rather than the finished recipe, and inherits them automatically into every recipe and sub-recipe that uses it. FoodCore is built this way: declare the 14 UK allergens once on an ingredient record and the declaration cascades upward through unlimited levels of sub-recipe into the finished product, its PPDS label and the allergen matrix. Any tool that asks you to type allergens onto each recipe will drift out of date the first time a supplier reformulates.
What is a sub-recipe, and why does it matter for allergens?
A sub-recipe is a recipe used as an ingredient inside another recipe: a bechamel in a lasagne, a pastry base across six pies, a spice blend across a range. Sub-recipes are where allergen information most often goes missing, because whoever builds the finished product sees one line saying 'white sauce 400g' and no sight of the flour and milk inside it. Good software resolves the sub-recipe down to its constituents and rolls the allergens back up.
How do allergens cascade through nested sub-recipes?
A parent recipe's allergens should be the union of everything beneath it, at every level. A spice blend containing mustard goes into a marinade, the marinade into a filling, the filling into a pie, the pie into a meal deal. Mustard must appear on the meal deal. The calculation should rerun whenever any level changes, so removing the mustard from the blend removes it from the meal deal automatically.
What is a compound ingredient and how do I record its allergens?
A compound ingredient is a bought-in product that is itself made from several ingredients: a stock powder, a mayonnaise, a chocolate coating, a curry paste. The allergen sits in your supplier's recipe, not yours, so you cannot deduce it from the product. Record it from the current supplier specification or pack label, enter every allergen declared, and note the specification date. Re-check whenever the supplier reissues a specification or changes packaging or site.
Should a 'may contain' warning be treated the same as an actual ingredient?
No. They are legally different. An allergen genuinely present is an ingredient and must be declared in the ingredients list, emphasised. A 'may contain' statement is a voluntary precautionary label describing a cross-contamination risk that controls cannot remove, and it must never substitute for declaring something you actually put in. Keep the two in separate fields so a warning does not harden into a declared ingredient three levels up.
If I change one ingredient, do all my products update automatically?
In an ingredient-level system, yes. Editing one ingredient's allergen profile recalculates every recipe and sub-recipe using it, and every label and matrix generated from them. A supplier adding sesame to a bread mix is one edit, not forty. On Growth and Core plans, version history also records who made the edit and when, and lets you restore the previous version.
Does allergen software make my business compliant?
No. Software makes accurate allergen management far easier to run and to evidence, but the legal responsibility stays with the food business operator. You remain responsible for the data you enter, for checking it against current supplier specifications, for the controls that prevent cross-contamination, and for the information on the label before sale. FoodCore assists with that work and records it; it does not assume the duty.
Further resources
FoodCore is kitchen management software built for small UK food businesses. We handle recipe costing, Natasha's Law labels, allergen matrices and order tracking.
Start free trial →