diff --git a/apps/api/src/lib/ingredient-matcher.ts b/apps/api/src/lib/ingredient-matcher.ts
index 467f13e..0ba0c3c 100644
--- a/apps/api/src/lib/ingredient-matcher.ts
+++ b/apps/api/src/lib/ingredient-matcher.ts
@@ -1,4 +1,8 @@
-import { INGREDIENT_LABELS_EN, UNIT_LABELS_EN } from "@batch-cooking/shared";
+import {
+  INGREDIENT_LABELS_EN,
+  INGREDIENT_LABEL_SYNONYMS_EN,
+  UNIT_LABELS_EN,
+} from "@batch-cooking/shared";
 import { prisma } from "../db/prisma.js";
 import { normalizeText } from "./tech-step-matcher.js";
 
@@ -168,13 +172,17 @@ export function extractQuantity(rawText: string): ExtractedQuantity {
   return { quantity, remainder: trimmed.slice(match[0].length).trim() };
 }
 
-/** Loads the full `Ingredient` catalog as {@link IngredientMatchEntry}s — one entry per key with an authored English label (see `INGREDIENT_LABELS_EN`); an ingredient with no English label yet is silently skipped, never a matching target. Meant to be fetched once per request and reused across every ingredient line, not re-queried per line. */
+/** Loads the full `Ingredient` catalog as {@link IngredientMatchEntry}s — one entry per key with an authored English label (see `INGREDIENT_LABELS_EN`), plus one extra entry per alternate wording (`INGREDIENT_LABEL_SYNONYMS_EN`, e.g. "Vanilla pod" alongside "Vanilla bean" — see issue #54) sharing the same `ingredientId`; `matchIngredientName` doesn't need to know synonyms exist, it just sees more candidate labels for the same ingredient. An ingredient with no English label yet is silently skipped, never a matching target. Meant to be fetched once per request and reused across every ingredient line, not re-queried per line. */
 export async function loadIngredientCatalog(): Promise<IngredientMatchEntry[]> {
   const ingredients = await prisma.ingredient.findMany({ select: { id: true, key: true } });
   const catalog: IngredientMatchEntry[] = [];
   for (const ingredient of ingredients) {
     const label = INGREDIENT_LABELS_EN[ingredient.key];
-    if (label !== undefined) catalog.push({ ingredientId: ingredient.id, label });
+    if (label === undefined) continue;
+    catalog.push({ ingredientId: ingredient.id, label });
+    for (const synonym of INGREDIENT_LABEL_SYNONYMS_EN[ingredient.key] ?? []) {
+      catalog.push({ ingredientId: ingredient.id, label: synonym });
+    }
   }
   return catalog;
 }
diff --git a/apps/api/src/lib/recipe-translation.ts b/apps/api/src/lib/recipe-translation.ts
index b93c493..1dd97c1 100644
--- a/apps/api/src/lib/recipe-translation.ts
+++ b/apps/api/src/lib/recipe-translation.ts
@@ -92,6 +92,14 @@ export function translateRecipeSteps(
   };
 }
 
+/**
+ * English label {@link matchUnit} is fed when a quantity was found but no
+ * unit word was — see the `unitId` fallback below. `"piece"` (`UNIT_LABELS_EN`,
+ * `packages/shared`) is the catalog's generic "counted, no further unit"
+ * entry (French "unité").
+ */
+const FALLBACK_COUNT_UNIT_LABEL = "piece";
+
 /**
  * Resolves each of `ingredients`' free-text `name`/`unit`/`quantity`
  * against `ingredientCatalog`/`unitCatalog` (see `ingredient-matcher.ts`).
@@ -101,6 +109,17 @@ export function translateRecipeSteps(
  * same for `unit` falling back to `extractQuantity`'s `remainder` before
  * being matched against `unitCatalog` — a source that already states a
  * clean unit/quantity is trusted over re-deriving it from `rawText`.
+ *
+ * When a quantity was found but nothing in the remaining text matched a
+ * unit (e.g. `"4 Egg Yolks"` — quantity `4`, remainder `"Egg Yolks"`, no
+ * unit word anywhere in it), `unitId` falls back to the catalog's generic
+ * `piece` unit rather than staying `null`: a bare count with no explicit
+ * unit word is overwhelmingly "N of them" (eggs, onions, cloves not
+ * spelled out as "clove") in practice, not a genuinely missing unit — see
+ * issue #53, where this previously left the import review form's submit
+ * button disabled with no indication why on almost any recipe with a
+ * whole-item ingredient. No fallback when `quantity` itself is `null`
+ * (e.g. `"To taste"`) — there's nothing to count, so nothing to default.
  */
 export function translateRecipeIngredients(
   ingredients: ParsedRecipeIngredient[],
@@ -112,7 +131,9 @@ export function translateRecipeIngredients(
     const extracted = extractQuantity(ingredient.rawText);
     const quantity = ingredient.quantity ?? extracted.quantity;
     const unitText = ingredient.unit ?? extracted.remainder;
-    const unitId = matchUnit(unitText, unitCatalog);
+    const unitId =
+      matchUnit(unitText, unitCatalog) ??
+      (quantity !== null ? matchUnit(FALLBACK_COUNT_UNIT_LABEL, unitCatalog) : null);
     return { ...ingredient, quantity, ingredientId, unitId };
   });
 }
diff --git a/apps/api/src/sources/the-meal-db.ts b/apps/api/src/sources/the-meal-db.ts
index 4789c4f..d4841d2 100644
--- a/apps/api/src/sources/the-meal-db.ts
+++ b/apps/api/src/sources/the-meal-db.ts
@@ -129,10 +129,17 @@ export const theMealDbAdapter: RecipeSourceAdapter<TheMealDbMeal> = {
 
     // Free-text instructions, usually one step per line — splitting on
     // blank/newlines is the closest this source gets to discrete steps.
+    // TheMealDB frequently numbers each step on its own line ahead of the
+    // paragraph that follows (e.g. "…melted.\n\n2\n\nPreheat oven…") rather
+    // than inline ("1. Preheat oven…") — the blank-line split above turns
+    // that lone number into its own "line", which would otherwise become a
+    // bogus step containing nothing but a digit. Drop those rather than
+    // keep them as steps in their own right (see issue #52).
     const steps = (meal.strInstructions ?? "")
       .split(/\r?\n+/)
       .map((line) => line.trim())
       .filter((line) => line.length > 0)
+      .filter((line) => !/^\d+\.?$/.test(line))
       .map((description) => ({ description, picture: null }));
     if (steps.length === 0) {
       throw new RecipeSourceParseError(
diff --git a/apps/api/test/ingredient-matcher.test.ts b/apps/api/test/ingredient-matcher.test.ts
index f50858e..072d0fc 100644
--- a/apps/api/test/ingredient-matcher.test.ts
+++ b/apps/api/test/ingredient-matcher.test.ts
@@ -1,3 +1,4 @@
+import { INGREDIENT_LABEL_SYNONYMS_EN } from "@batch-cooking/shared";
 import { expect } from "chai";
 import { prisma } from "../src/db/prisma.js";
 import {
@@ -75,6 +76,15 @@ describe("ingredient-matcher", () => {
       expect(matchIngredientName("", catalog)).to.equal(null);
     });
 
+    it("matches an alternate wording of the same ingredient via a second catalog entry sharing its ingredientId (issue #54)", () => {
+      const vanillaBean: IngredientMatchEntry = { ingredientId: 8, label: "Vanilla bean" };
+      const vanillaBeanSynonym: IngredientMatchEntry = { ingredientId: 8, label: "Vanilla pod" };
+      const synonymCatalog = [vanillaBean, vanillaBeanSynonym];
+
+      expect(matchIngredientName("1 vanilla pod", synonymCatalog)).to.equal(8);
+      expect(matchIngredientName("1 vanilla bean", synonymCatalog)).to.equal(8);
+    });
+
     it("breaks a same-specificity tie by the lowest ingredientId", () => {
       const onionA: IngredientMatchEntry = { ingredientId: 20, label: "Onion" };
       const onionB: IngredientMatchEntry = { ingredientId: 21, label: "Onion" };
@@ -190,18 +200,33 @@ describe("ingredient-matcher", () => {
       await prisma.$disconnect();
     });
 
-    it("loads one entry per Ingredient that has an English label, keyed by real ingredientId", async () => {
+    it("loads one entry per Ingredient that has an English label, plus one per alternate wording (INGREDIENT_LABEL_SYNONYMS_EN), keyed by real ingredientId", async () => {
       const tomato = await prisma.ingredient.findFirstOrThrow({ where: { key: "tomato" } });
+      const vanillaBean = await prisma.ingredient.findFirstOrThrow({
+        where: { key: "vanillaBean" },
+      });
       const ingredientCount = await prisma.ingredient.count();
+      const synonymCount = Object.values(INGREDIENT_LABEL_SYNONYMS_EN).reduce(
+        (sum, synonyms) => sum + synonyms.length,
+        0,
+      );
 
       const catalog = await loadIngredientCatalog();
 
       // Every seeded ingredient has an authored English label (verified at
       // generation time — see packages/shared/src/data/catalog-labels-en.ts),
-      // so nothing should be silently skipped.
-      expect(catalog).to.have.length(ingredientCount);
+      // so nothing should be silently skipped — plus one extra entry per
+      // synonym (issue #54), sharing the same ingredientId as the primary
+      // label's entry.
+      expect(catalog).to.have.length(ingredientCount + synonymCount);
       const tomatoEntry = catalog.find((entry) => entry.ingredientId === tomato.id);
       expect(tomatoEntry?.label).to.equal("Tomato");
+
+      const vanillaBeanEntries = catalog.filter((entry) => entry.ingredientId === vanillaBean.id);
+      expect(vanillaBeanEntries.map((entry) => entry.label)).to.deep.equal([
+        "Vanilla bean",
+        "Vanilla pod",
+      ]);
     });
 
     it("loads one entry per Unit that has English synonyms, keyed by real unitId", async () => {
diff --git a/apps/api/test/recipe-translation.test.ts b/apps/api/test/recipe-translation.test.ts
index 636fad8..52205ab 100644
--- a/apps/api/test/recipe-translation.test.ts
+++ b/apps/api/test/recipe-translation.test.ts
@@ -196,6 +196,32 @@ describe("recipe-translation", () => {
       expect(translated[0].unitId).to.equal(gram.unitId);
     });
 
+    it("falls back to the generic 'piece' unit when a quantity was found but no unit word was (issue #53)", () => {
+      const piece: UnitMatchEntry = { unitId: 12, synonyms: ["piece", "pieces", "pc", "pcs"] };
+
+      const translated = translateRecipeIngredients(
+        [buildIngredient({ rawText: "4 Egg Yolks", name: "Egg Yolks" })],
+        [],
+        [gram, cup, piece],
+      );
+
+      expect(translated[0].quantity).to.equal(4);
+      expect(translated[0].unitId).to.equal(piece.unitId);
+    });
+
+    it("does not fall back to 'piece' when there's no quantity at all to count", () => {
+      const piece: UnitMatchEntry = { unitId: 12, synonyms: ["piece", "pieces", "pc", "pcs"] };
+
+      const translated = translateRecipeIngredients(
+        [buildIngredient({ rawText: "salt to taste", name: "salt" })],
+        [],
+        [piece],
+      );
+
+      expect(translated[0].quantity).to.equal(null);
+      expect(translated[0].unitId).to.equal(null);
+    });
+
     it("leaves quantity/unitId null when rawText has neither a leading number nor a recognizable unit", () => {
       const translated = translateRecipeIngredients(
         [buildIngredient({ rawText: "salt to taste", name: "salt" })],
diff --git a/apps/api/test/recipe.test.ts b/apps/api/test/recipe.test.ts
index d35c720..c78c3f5 100644
--- a/apps/api/test/recipe.test.ts
+++ b/apps/api/test/recipe.test.ts
@@ -568,6 +568,32 @@ describe("Recipes", () => {
       expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
     });
 
+    it("rejects the same ingredientId listed twice with 400 VALIDATION_ERROR, not a 500 (issue #53 follow-up)", async () => {
+      // `RecipeIngredient`'s primary key is `(recipeId, ingredientId)` — a
+      // manual creation can't reach this via the web UI (`IngredientPicker`
+      // hides an already-picked ingredient), but nothing stops a raw
+      // request (or a source import, whose lines aren't deduplicated) from
+      // sending it — must fail cleanly instead of crashing on the DB's
+      // unique-constraint violation.
+      const { agent } = await signup();
+      const tomate = await ingredientId("tomato");
+      const piece = await unitId("piece");
+
+      const res = await agent.post("/recipes").send({
+        name: "Test",
+        portions: 4,
+        dietIds: [],
+        ingredients: [
+          { ingredientId: tomate, quantity: 1, unitId: piece },
+          { ingredientId: tomate, quantity: 2, unitId: piece },
+        ],
+        steps: [{ description: "Étape" }],
+      });
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
+
     it("rejects a missing or non-positive portions with 400 VALIDATION_ERROR", async () => {
       const { agent } = await signup();
       const tomate = await ingredientId("tomato");
diff --git a/apps/api/test/sources.test.ts b/apps/api/test/sources.test.ts
index 9107128..5441943 100644
--- a/apps/api/test/sources.test.ts
+++ b/apps/api/test/sources.test.ts
@@ -357,6 +357,23 @@ describe("Sources", () => {
       expect(res.body.code).to.equal(ErrorCode.INGREDIENT_NOT_FOUND);
     });
 
+    it("rejects the same ingredientId listed twice with 400 VALIDATION_ERROR, not a 500 (issue #53 follow-up)", async () => {
+      // A source's raw ingredient lines aren't deduplicated by the matcher
+      // (see `ingredient-matcher.ts`) — two different lines (e.g. "Egg
+      // Yolks" and "Eggs") can resolve to the same catalog ingredient, same
+      // as `recipe.test.ts`'s equivalent for a manual creation, just
+      // reached here through the review screen's pre-filled payload
+      // instead.
+      const { agent } = await enableFakeSource();
+      const payload = await buildImportPayload();
+      payload.ingredients.push({ ...payload.ingredients[0] });
+
+      const res = await agent.post("/sources/fakeSource/import/1").send(payload);
+
+      expect(res.status).to.equal(400);
+      expect(res.body.code).to.equal(ErrorCode.VALIDATION_ERROR);
+    });
+
     it("rejects a second household's import of the same item too — the item's identity is global, not per-household", async () => {
       // Registers/syncs the adapter once — enableFakeSource() itself does
       // this too, and registerRecipeSource() throws on a duplicate key, so
diff --git a/apps/api/test/the-meal-db.test.ts b/apps/api/test/the-meal-db.test.ts
index 7427146..e0e0d99 100644
--- a/apps/api/test/the-meal-db.test.ts
+++ b/apps/api/test/the-meal-db.test.ts
@@ -154,6 +154,20 @@ describe("theMealDbAdapter", () => {
       ]);
     });
 
+    it("drops lone step-number lines instead of turning them into bogus steps (issue #52)", () => {
+      const parsed = theMealDbAdapter.parse({
+        ...baseMeal,
+        strInstructions:
+          "For the caramel, melt the sugar.\r\n\r\n2\r\n\r\nPreheat the oven.\r\n\r\n3\r\n\r\nBake it.",
+      });
+
+      expect(parsed.steps).to.deep.equal([
+        { description: "For the caramel, melt the sugar.", picture: null },
+        { description: "Preheat the oven.", picture: null },
+        { description: "Bake it.", picture: null },
+      ]);
+    });
+
     it("throws RecipeSourceParseError when the meal has no name", () => {
       expect(() => theMealDbAdapter.parse({ ...baseMeal, strMeal: null })).to.throw(
         RecipeSourceParseError,
diff --git a/apps/web/src/features/recipes/IngredientRow.tsx b/apps/web/src/features/recipes/IngredientRow.tsx
index 5fc47e1..ea2c360 100644
--- a/apps/web/src/features/recipes/IngredientRow.tsx
+++ b/apps/web/src/features/recipes/IngredientRow.tsx
@@ -12,6 +12,7 @@ export function IngredientRow({
   quantity,
   unitId,
   unitsCatalog,
+  duplicate = false,
   onQuantityChange,
   onUnitChange,
   onRemove,
@@ -20,14 +21,24 @@ export function IngredientRow({
   quantity: string;
   unitId: number | null;
   unitsCatalog: UnitView[];
+  /** This ingredient is also picked by another line in the same form — `RecipeIngredient`'s primary key is `(recipeId, ingredientId)`, one row per ingredient (schema.prisma), so submitting two lines for it would fail. Never true for a manually-added line (`IngredientPicker`'s `excludeIds` already prevents picking the same ingredient twice) — only reachable via a source import, whose raw lines aren't deduplicated (e.g. "Egg Yolks" and "Eggs" both resolving to "Egg" — see issue #53's `RecipeImportForm`). */
+  duplicate?: boolean;
   onQuantityChange: (quantity: string) => void;
   onUnitChange: (unitId: number) => void;
   onRemove: () => void;
 }) {
   const { t } = useTranslation();
+  // No unit picked yet — surfaced with a highlighted `<select>` + inline
+  // hint rather than silently keeping the form's submit button disabled
+  // (see issue #53: an import pre-filled from a source can land here with
+  // an ingredient resolved but no unit — e.g. a bare count like "4 Egg
+  // Yolks" — and nothing used to tell the user which line was blocking
+  // them, or why).
+  const unitMissing = unitId === null;
+  const needsAttention = unitMissing || duplicate;
 
   return (
-    <li className="ingredient-row">
+    <li className={needsAttention ? "ingredient-row ingredient-row--incomplete" : "ingredient-row"}>
       <span className="ingredient-row__icon" aria-hidden="true">
         <IngredientTypeIcon icon={ingredient.icon} />
       </span>
@@ -46,6 +57,7 @@ export function IngredientRow({
         value={unitId ?? ""}
         onChange={(e) => onUnitChange(Number(e.target.value))}
         aria-label={t("recipes.form.unitLabel")}
+        aria-invalid={unitMissing}
       >
         <option value="" disabled>
           {t("recipes.form.unitPlaceholder")}
@@ -70,6 +82,14 @@ export function IngredientRow({
       >
         ✕
       </button>
+      {unitMissing && (
+        <p className="field-error ingredient-row__error">{t("recipes.form.unitMissingHint")}</p>
+      )}
+      {duplicate && (
+        <p className="field-error ingredient-row__error">
+          {t("recipes.form.duplicateIngredientHint")}
+        </p>
+      )}
     </li>
   );
 }
diff --git a/apps/web/src/features/recipes/RecipeImportForm.tsx b/apps/web/src/features/recipes/RecipeImportForm.tsx
index c283436..e92252b 100644
--- a/apps/web/src/features/recipes/RecipeImportForm.tsx
+++ b/apps/web/src/features/recipes/RecipeImportForm.tsx
@@ -212,12 +212,38 @@ export function RecipeImportForm({
     setResolvingKey((current) => (current === key ? null : current));
   }
 
+  // Surfaced next to the submit button (see the `unitMissingHint` per-row
+  // hint in `IngredientRow` for the same thing at the line level) — without
+  // this, a pre-filled import whose auto-matched ingredients are otherwise
+  // complete could leave `canSubmit` false with nothing on the page saying
+  // why (see issue #53).
+  const hasIngredientMissingUnit = ingredientLines.some((line) => line.unitId === null);
+
+  // Two raw source lines can independently resolve to the same catalog
+  // ingredient (e.g. "Egg Yolks" and "Eggs" both matching "Egg") —
+  // `RecipeIngredient`'s primary key is `(recipeId, ingredientId)`, one row
+  // per ingredient (schema.prisma), so submitting both would otherwise fail
+  // (`createRecipeSchema` now rejects it, see its own doc comment). Blocked
+  // here too, with each duplicate row highlighted, rather than letting the
+  // user find out only after clicking "Importer".
+  const duplicateIngredientIds = (() => {
+    const seen = new Set<number>();
+    const duplicates = new Set<number>();
+    for (const line of ingredientLines) {
+      if (seen.has(line.ingredient.id)) duplicates.add(line.ingredient.id);
+      seen.add(line.ingredient.id);
+    }
+    return duplicates;
+  })();
+  const hasDuplicateIngredient = duplicateIngredientIds.size > 0;
+
   const canSubmit =
     name.trim().length > 0 &&
     Number.isInteger(Number(portions)) &&
     Number(portions) > 0 &&
     ingredientLines.length > 0 &&
     ingredientLines.every((line) => Number(line.quantity) > 0 && line.unitId !== null) &&
+    !hasDuplicateIngredient &&
     unresolvedIngredients.length === 0 &&
     steps.length > 0 &&
     steps.every((step) => step.description.trim().length > 0);
@@ -368,6 +394,7 @@ export function RecipeImportForm({
               quantity={line.quantity}
               unitId={line.unitId}
               unitsCatalog={unitsCatalog}
+              duplicate={duplicateIngredientIds.has(line.ingredient.id)}
               onQuantityChange={(quantity) => updateIngredientLine(line.key, { quantity })}
               onUnitChange={(unitId) => updateIngredientLine(line.key, { unitId })}
               onRemove={() => removeIngredientLine(line.key)}
@@ -424,6 +451,12 @@ export function RecipeImportForm({
       </section>
 
       {formError && <p className="form-error">{formError}</p>}
+      {!canSubmit && hasIngredientMissingUnit && (
+        <p className="form-error">{t("recipes.form.incompleteIngredientsHint")}</p>
+      )}
+      {!canSubmit && hasDuplicateIngredient && (
+        <p className="form-error">{t("recipes.form.duplicateIngredientsHint")}</p>
+      )}
 
       <div className="recipe-form__actions">
         <button type="submit" disabled={isSubmitting || !canSubmit}>
diff --git a/apps/web/src/features/recipes/recipes.scss b/apps/web/src/features/recipes/recipes.scss
index aad17c0..26d4e96 100644
--- a/apps/web/src/features/recipes/recipes.scss
+++ b/apps/web/src/features/recipes/recipes.scss
@@ -923,6 +923,20 @@
       border-color: var(--color-error);
     }
   }
+
+  // A resolved ingredient with no unit picked — the form's submit stays
+  // disabled until this is fixed, so it needs to be obvious *which* row is
+  // the reason why (see issue #53). `__error` takes the row's full width
+  // (it comes after the `flex-wrap`ped controls above, so it naturally
+  // drops to its own line).
+  &--incomplete &__unit {
+    border-color: var(--color-error);
+  }
+
+  &__error {
+    width: 100%;
+    margin: 0;
+  }
 }
 
 // --- Ingredient picker (recipe form + disliked-ingredients field) ----------
diff --git a/apps/web/src/locales/fr/translation.json b/apps/web/src/locales/fr/translation.json
index fa8f556..ea0f130 100644
--- a/apps/web/src/locales/fr/translation.json
+++ b/apps/web/src/locales/fr/translation.json
@@ -260,6 +260,10 @@
       "quantityLabel": "Quantité",
       "unitLabel": "Unité",
       "unitPlaceholder": "Choisir une unité",
+      "unitMissingHint": "Choisissez une unité pour cet ingrédient.",
+      "duplicateIngredientHint": "Cet ingrédient apparaît plusieurs fois — retirez les doublons.",
+      "incompleteIngredientsHint": "Complétez la quantité et l'unité des ingrédients surlignés ci-dessus avant de continuer.",
+      "duplicateIngredientsHint": "Retirez les doublons parmi les ingrédients surlignés ci-dessus avant de continuer.",
       "removeIngredient": "Retirer cet ingrédient",
       "stepDescriptionPlaceholder": "Décrivez cette étape…",
       "stepPicturePlaceholder": "Photo de l'étape (URL, optionnel)",
diff --git a/apps/web/src/pages/RecipeFormPage.tsx b/apps/web/src/pages/RecipeFormPage.tsx
index b44878d..fd0fab9 100644
--- a/apps/web/src/pages/RecipeFormPage.tsx
+++ b/apps/web/src/pages/RecipeFormPage.tsx
@@ -138,6 +138,13 @@ export function RecipeFormPage() {
     setIngredientLines((lines) => lines.filter((line) => line.key !== key));
   }
 
+  // Surfaced next to the submit button when it's the reason `canSubmit` is
+  // false — same "don't leave the button silently disabled" reasoning as
+  // `RecipeImportForm` (issue #53), just less likely to bite here since a
+  // manually-added line starts with no unit by design, right where the
+  // person is already looking.
+  const hasIngredientMissingUnit = ingredientLines.some((line) => line.unitId === null);
+
   // Gates the submit button — the schema (checked again on submit, see
   // `handleSubmit`) is the source of truth, this is just instant feedback
   // that doesn't need a round trip through zod on every keystroke.
@@ -294,6 +301,9 @@ export function RecipeFormPage() {
       </section>
 
       {formError && <p className="form-error">{formError}</p>}
+      {!canSubmit && hasIngredientMissingUnit && (
+        <p className="form-error">{t("recipes.form.incompleteIngredientsHint")}</p>
+      )}
 
       <div className="recipe-form__actions">
         <button type="submit" disabled={isSubmitting || !canSubmit}>
diff --git a/packages/shared/src/data/catalog-labels-en.ts b/packages/shared/src/data/catalog-labels-en.ts
index 417d813..848ecd3 100644
--- a/packages/shared/src/data/catalog-labels-en.ts
+++ b/packages/shared/src/data/catalog-labels-en.ts
@@ -600,6 +600,24 @@ export const INGREDIENT_LABELS_EN: Record<string, string> = {
   caneSyrup: "Cane syrup",
 };
 
+/**
+ * Extra English matching phrases for a handful of {@link INGREDIENT_LABELS_EN}
+ * entries whose primary label doesn't cover a common alternate wording used
+ * by real recipe sources (e.g. TheMealDB's `"Vanilla Pod"` vs. this
+ * catalog's own `"Vanilla bean"`) — see issue #54. Deliberately a *second*,
+ * mostly-empty map rather than widening `INGREDIENT_LABELS_EN` itself to
+ * `string | string[]` for every one of its ~550 entries: only entries that
+ * actually need an alternate wording are listed here, so this stays a
+ * short, easy-to-scan list of exceptions instead of turning every other
+ * entry into a single-item array for no reason. `apps/api`'s
+ * `ingredient-matcher.ts` (`loadIngredientCatalog`) adds one extra catalog
+ * entry per synonym, alongside the primary label — matched exactly the same
+ * way, `matchIngredientName` itself doesn't need to know synonyms exist.
+ */
+export const INGREDIENT_LABEL_SYNONYMS_EN: Record<string, string[]> = {
+  vanillaBean: ["Vanilla pod"],
+};
+
 /**
  * English matching synonyms for the `Unit` reference catalog
  * (`apps/api/src/db/reference-seed-data.ts`'s `UNITS`), keyed by
diff --git a/packages/shared/src/schemas/recipe.ts b/packages/shared/src/schemas/recipe.ts
index de31a28..4424c0a 100644
--- a/packages/shared/src/schemas/recipe.ts
+++ b/packages/shared/src/schemas/recipe.ts
@@ -37,18 +37,42 @@ const recipeStepInputSchema = z.object({
 const recipeVisibilitySchema = z.enum(["PERSONAL", "HOUSE", "PUBLIC"]);
 
 /** Payload accepted by `POST /recipes` and `PATCH /recipes/:id` (a full replace, not a partial merge — see the API's `recipe.service.ts`). */
-export const createRecipeSchema = z.object({
-  name: z.string().trim().min(1, "Le nom de la recette est requis").max(150),
-  description: z.string().trim().max(2000).nullable().optional(),
-  picture: z.string().trim().url("URL invalide").nullable().optional(),
-  /** How many portions this recipe yields as written — see `Recipe.portions` in schema.prisma. */
-  portions: z.number().int().positive("Le nombre de portions doit être positif"),
-  visibility: recipeVisibilitySchema.default("PERSONAL"),
-  /** `dietId`s tagged as "this recipe suits this regime" — a manual reminder, not computed from ingredients. Empty = no regime associated. */
-  dietIds: z.array(z.number().int().positive()),
-  ingredients: z.array(recipeIngredientInputSchema).min(1, "Au moins un ingrédient est requis"),
-  steps: z.array(recipeStepInputSchema).min(1, "Au moins une étape est requise"),
-});
+export const createRecipeSchema = z
+  .object({
+    name: z.string().trim().min(1, "Le nom de la recette est requis").max(150),
+    description: z.string().trim().max(2000).nullable().optional(),
+    picture: z.string().trim().url("URL invalide").nullable().optional(),
+    /** How many portions this recipe yields as written — see `Recipe.portions` in schema.prisma. */
+    portions: z.number().int().positive("Le nombre de portions doit être positif"),
+    visibility: recipeVisibilitySchema.default("PERSONAL"),
+    /** `dietId`s tagged as "this recipe suits this regime" — a manual reminder, not computed from ingredients. Empty = no regime associated. */
+    dietIds: z.array(z.number().int().positive()),
+    ingredients: z.array(recipeIngredientInputSchema).min(1, "Au moins un ingrédient est requis"),
+    steps: z.array(recipeStepInputSchema).min(1, "Au moins une étape est requise"),
+  })
+  // `RecipeIngredient`'s primary key is `(recipeId, ingredientId)` — one row
+  // per ingredient per recipe (schema.prisma) — so two lines with the same
+  // `ingredientId` would otherwise reach `prisma.recipe.create()` and crash
+  // with an unhandled `P2002` unique-constraint 500, instead of the clean
+  // 400 every other invalid shape gets here. The manual recipe form can't
+  // produce this (`IngredientPicker`'s `excludeIds` hides an
+  // already-selected ingredient), but a source import can: two raw lines
+  // ("Egg Yolks", "Eggs") can independently resolve to the same catalog
+  // ingredient (see `RecipeImportForm.tsx`, issue #53's `matchUnit`
+  // fallback made this reachable in practice) — rejected here rather than
+  // silently summed, since two lines resolving to the same ingredient
+  // aren't necessarily interchangeable quantities (different units,
+  // different confidence in the match).
+  .refine(
+    (input) => {
+      const ingredientIds = input.ingredients.map((ingredient) => ingredient.ingredientId);
+      return new Set(ingredientIds).size === ingredientIds.length;
+    },
+    {
+      message: "Un même ingrédient ne peut pas apparaître plusieurs fois dans une recette",
+      path: ["ingredients"],
+    },
+  );
 /** Inferred TS type for {@link createRecipeSchema}'s validated output. */
 export type CreateRecipeInput = z.infer<typeof createRecipeSchema>;