diff --git a/app/Domain/Formats/EntrantSlot.php b/app/Domain/Formats/EntrantSlot.php
new file mode 100644
index 0000000..5c65a34
--- /dev/null
+++ b/app/Domain/Formats/EntrantSlot.php
@@ -0,0 +1,128 @@
+<?php
+
+namespace App\Domain\Formats;
+
+use App\Models\Stage;
+use DomainException;
+
+/**
+ * One entry slot in a knockout bracket, describing where its team comes
+ * from rather than who the team is. Stored on the knockout stage as
+ * stage.config['entrants'] — an ordered list where consecutive pairs
+ * (0,1), (2,3)… are the round-1 matchups, mirroring the generator's
+ * bracket_position layout so slot 2p is game p's home side and 2p+1 its
+ * away side.
+ *
+ * Two shapes:
+ *   ['type' => 'group', 'group' => 'Group A', 'position' => 1]
+ *     — the team finishing at `position` in the named group of the
+ *       previous stage (1 = winner, 2 = runner-up, …).
+ *   ['type' => 'best_placed', 'rank' => 2]
+ *     — the rank-th team in the cross-group best-placed ranking (the
+ *       BestPlacedCalculator table). Which concrete slot each best-placed
+ *       team fills is refined by the allocation step when seeding.
+ */
+final readonly class EntrantSlot
+{
+    private function __construct(
+        public string $type,
+        public ?string $group,
+        public ?int $position,
+        public ?int $rank,
+    ) {
+        //
+    }
+
+    /**
+     * @param  array<string, mixed>  $raw
+     */
+    public static function fromArray(array $raw): self
+    {
+        $type = $raw['type'] ?? null;
+
+        if ($type === 'group') {
+            $group = $raw['group'] ?? null;
+            $position = $raw['position'] ?? null;
+
+            if (! is_string($group) || $group === '' || ! is_numeric($position) || (int) $position < 1) {
+                throw new DomainException('A group entrant slot needs a group name and a position of at least 1.');
+            }
+
+            return new self('group', $group, (int) $position, null);
+        }
+
+        if ($type === 'best_placed') {
+            $rank = $raw['rank'] ?? null;
+
+            if (! is_numeric($rank) || (int) $rank < 1) {
+                throw new DomainException('A best-placed entrant slot needs a rank of at least 1.');
+            }
+
+            return new self('best_placed', null, null, (int) $rank);
+        }
+
+        throw new DomainException("Unknown entrant slot type [{$type}]; expected 'group' or 'best_placed'.");
+    }
+
+    /**
+     * The stage's configured entrant slots, in bracket order. Empty array
+     * when the stage has none configured.
+     *
+     * @return array<int, self>
+     */
+    public static function listForStage(Stage $stage): array
+    {
+        $entrants = $stage->config['entrants'] ?? null;
+
+        if (! is_array($entrants) || $entrants === []) {
+            return [];
+        }
+
+        return array_map(
+            fn (array $raw): self => self::fromArray($raw),
+            array_values($entrants),
+        );
+    }
+
+    /**
+     * Human label for an unfilled bracket slot, e.g. "Winner Group A",
+     * "Runner-up Group B", "3rd Group C", "Best-placed #4".
+     */
+    public function label(): string
+    {
+        if ($this->type === 'best_placed') {
+            return "Best-placed #{$this->rank}";
+        }
+
+        return match ($this->position) {
+            1 => "Winner {$this->group}",
+            2 => "Runner-up {$this->group}",
+            default => self::ordinal((int) $this->position)." {$this->group}",
+        };
+    }
+
+    /**
+     * @return array{type: string, group?: string, position?: int, rank?: int}
+     */
+    public function toArray(): array
+    {
+        if ($this->type === 'best_placed') {
+            return ['type' => 'best_placed', 'rank' => (int) $this->rank];
+        }
+
+        return ['type' => 'group', 'group' => (string) $this->group, 'position' => (int) $this->position];
+    }
+
+    private static function ordinal(int $n): string
+    {
+        $suffix = match (true) {
+            $n % 100 >= 11 && $n % 100 <= 13 => 'th',
+            $n % 10 === 1 => 'st',
+            $n % 10 === 2 => 'nd',
+            $n % 10 === 3 => 'rd',
+            default => 'th',
+        };
+
+        return $n.$suffix;
+    }
+}
diff --git a/app/Domain/Formats/SingleEliminationGenerator.php b/app/Domain/Formats/SingleEliminationGenerator.php
index a0bbc76..ad2933e 100644
--- a/app/Domain/Formats/SingleEliminationGenerator.php
+++ b/app/Domain/Formats/SingleEliminationGenerator.php
@@ -30,6 +30,13 @@
  * Seeding: standard bracket seeding so the top two seeds can only meet in the
  * final. Lowest seed (first in input) is strongest; phantom seeds beyond n are
  * the byes and fall to the strongest real seeds.
+ *
+ * Entrant mode: when the stage declares config['entrants'] (slot descriptors
+ * like "Winner Group A" — see EntrantSlot), the bracket's shape comes from
+ * that list instead of the season's teams: every game is emitted as a TBD
+ * placeholder, and the seeding action fills round 1 from the previous stage's
+ * final standings. Consecutive descriptor pairs are the round-1 matchups, so
+ * the descriptor list *is* the pairing template.
  */
 class SingleEliminationGenerator implements FixtureGenerator
 {
@@ -38,6 +45,12 @@ class SingleEliminationGenerator implements FixtureGenerator
      */
     public function generate(Stage $stage): Collection
     {
+        $entrants = EntrantSlot::listForStage($stage);
+
+        if ($entrants !== []) {
+            return $this->generatePlaceholders($stage, count($entrants));
+        }
+
         $teams = $stage->season->teams->values();
         $n = $teams->count();
 
@@ -105,6 +118,41 @@ public function generate(Stage $stage): Collection
         return $games;
     }
 
+    /**
+     * Emit an all-TBD bracket sized to the entrant list: every game in every
+     * round carries null teams. Round 1 gets filled by the stage-seeding
+     * action; later rounds fill as winners advance.
+     *
+     * @return Collection<int, array{home_team_id: null, away_team_id: null, group_id: null, round: int, bracket_position: int}>
+     */
+    private function generatePlaceholders(Stage $stage, int $capacity): Collection
+    {
+        if ($capacity < 2 || $capacity !== self::nextPowerOfTwo($capacity)) {
+            throw new DomainException(
+                "Stage [{$stage->id}] has {$capacity} entrant slots; a knockout bracket needs a power of two (2, 4, 8, 16, …)."
+            );
+        }
+
+        $rounds = (int) log($capacity, 2);
+        $games = collect();
+
+        for ($round = 1; $round <= $rounds; $round++) {
+            $slots = intdiv($capacity, 2 ** $round);
+
+            for ($position = 0; $position < $slots; $position++) {
+                $games->push([
+                    'home_team_id' => null,
+                    'away_team_id' => null,
+                    'group_id' => null,
+                    'round' => $round,
+                    'bracket_position' => $position,
+                ]);
+            }
+        }
+
+        return $games;
+    }
+
     /**
      * Standard bracket seed ordering for a 2^rounds-team bracket. Returns
      * 1-based seeds laid out so consecutive pairs (0,1), (2,3)… are the
diff --git a/app/Http/Controllers/StagesController.php b/app/Http/Controllers/StagesController.php
index 3263b2c..856fd7e 100644
--- a/app/Http/Controllers/StagesController.php
+++ b/app/Http/Controllers/StagesController.php
@@ -3,6 +3,7 @@
 namespace App\Http\Controllers;
 
 use App\Actions\GenerateFixtures;
+use App\Domain\Formats\EntrantSlot;
 use App\Domain\Standings\BestPlacedCalculator;
 use App\Domain\Standings\StandingsRegistry;
 use App\Enums\StageFormat;
@@ -163,6 +164,8 @@ private function buildBracket(Stage $stage): ?array
             return null;
         }
 
+        $entrants = $this->entrantSlots($stage);
+
         return $byRound
             ->map(fn ($games, $round) => [
                 'round' => (int) $round,
@@ -172,6 +175,8 @@ private function buildBracket(Stage $stage): ?array
                     'bracket_position' => $game->bracket_position,
                     'home_team' => $game->homeTeam?->only(['id', 'name', 'acronym']),
                     'away_team' => $game->awayTeam?->only(['id', 'name', 'acronym']),
+                    'home_placeholder' => $this->slotPlaceholder($entrants, (int) $round, $game, 'home'),
+                    'away_placeholder' => $this->slotPlaceholder($entrants, (int) $round, $game, 'away'),
                     'home_team_score' => $game->result?->home_team_score,
                     'away_team_score' => $game->result?->away_team_score,
                     'status' => $game->status->value,
@@ -182,6 +187,43 @@ private function buildBracket(Stage $stage): ?array
             ->all();
     }
 
+    /**
+     * The stage's entrant slot descriptors, or [] when unset/invalid — a
+     * malformed config should degrade to plain TBD slots, not a 500.
+     *
+     * @return array<int, EntrantSlot>
+     */
+    private function entrantSlots(Stage $stage): array
+    {
+        try {
+            return EntrantSlot::listForStage($stage);
+        } catch (DomainException) {
+            return [];
+        }
+    }
+
+    /**
+     * Descriptor label for an unfilled round-1 slot ("Winner Group A"),
+     * null once a real team occupies it or for rounds the descriptors
+     * don't cover.
+     *
+     * @param  array<int, EntrantSlot>  $entrants
+     */
+    private function slotPlaceholder(array $entrants, int $round, Game $game, string $side): ?string
+    {
+        if ($round !== 1 || $entrants === []) {
+            return null;
+        }
+
+        if (($side === 'home' ? $game->home_team_id : $game->away_team_id) !== null) {
+            return null;
+        }
+
+        $slot = $entrants[2 * $game->bracket_position + ($side === 'home' ? 0 : 1)] ?? null;
+
+        return $slot?->label();
+    }
+
     /**
      * 'home' / 'away' once a game is decided, otherwise null.
      */
@@ -219,9 +261,45 @@ public function edit(League $league, Season $season, Stage $stage): Response
             'season' => $season->only(['id', 'name']),
             'stage' => $stage,
             'formats' => $this->formatOptions(),
+            'sourceStage' => $stage->format->isBracket() ? $this->buildSourceStage($season, $stage) : null,
         ]);
     }
 
+    /**
+     * The grouped stage that feeds this knockout stage — the nearest earlier
+     * stage (by order, then id) whose format has groups. Used by the entrant
+     * builder to offer "Winner Group A"-style slot options. Null when the
+     * season has no earlier grouped stage.
+     *
+     * @return null|array{id: int, name: string, advances_count: int, best_placed_count: int, groups: array<int, array{id: int, name: string}>}
+     */
+    private function buildSourceStage(Season $season, Stage $stage): ?array
+    {
+        $source = $season->stages()
+            ->where(fn ($q) => $q
+                ->where('order', '<', $stage->order)
+                ->orWhere(fn ($q2) => $q2->where('order', $stage->order)->where('id', '<', $stage->id)))
+            ->whereIn('format', [StageFormat::GroupStage->value, StageFormat::Conference->value])
+            ->orderByDesc('order')
+            ->orderByDesc('id')
+            ->with('groups:id,stage_id,name,order')
+            ->first();
+
+        if ($source === null) {
+            return null;
+        }
+
+        return [
+            'id' => $source->id,
+            'name' => $source->name,
+            'advances_count' => $source->advances_count ?? 2,
+            'best_placed_count' => (int) ($source->config['best_placed_count'] ?? 0),
+            'groups' => $source->groups
+                ->map(fn ($group) => ['id' => $group->id, 'name' => $group->name])
+                ->all(),
+        ];
+    }
+
     public function update(UpdateStageRequest $request, League $league, Season $season, Stage $stage): RedirectResponse
     {
         $this->ensureSeasonInLeague($league, $season);
diff --git a/app/Http/Requests/StoreStageRequest.php b/app/Http/Requests/StoreStageRequest.php
index c37fae8..873852f 100644
--- a/app/Http/Requests/StoreStageRequest.php
+++ b/app/Http/Requests/StoreStageRequest.php
@@ -2,8 +2,11 @@
 
 namespace App\Http\Requests;
 
+use App\Domain\Formats\EntrantSlot;
 use App\Enums\StageFormat;
 use App\Models\Season;
+use Closure;
+use DomainException;
 use Illuminate\Contracts\Validation\ValidationRule;
 use Illuminate\Foundation\Http\FormRequest;
 use Illuminate\Validation\Rule;
@@ -42,9 +45,64 @@ public function rules(): array
             'config' => ['nullable', 'array'],
             'config.legs_per_group' => ['sometimes', 'integer', 'in:1,2'],
             'config.best_placed_count' => ['sometimes', 'integer', 'min:1', 'max:16'],
+            'config.entrants' => ['sometimes', 'array', self::entrantsRule()],
         ];
     }
 
+    /**
+     * Shared shape check for config.entrants: a power-of-two-sized list of
+     * valid slot descriptors (see EntrantSlot).
+     */
+    public static function entrantsRule(): Closure
+    {
+        return function (string $attribute, mixed $value, Closure $fail): void {
+            if (! is_array($value)) {
+                return;
+            }
+
+            $count = count($value);
+
+            if ($count < 2 || ($count & ($count - 1)) !== 0) {
+                $fail("Entrant slots must total a power of two (2, 4, 8, 16, …) to form a bracket; got {$count}.");
+
+                return;
+            }
+
+            foreach (array_values($value) as $index => $slot) {
+                try {
+                    EntrantSlot::fromArray(is_array($slot) ? $slot : []);
+                } catch (DomainException $e) {
+                    $fail('Slot '.($index + 1).': '.$e->getMessage());
+
+                    return;
+                }
+            }
+        };
+    }
+
+    /**
+     * Canonicalize an incoming entrants list (string ints → ints, dropped
+     * extraneous keys) while leaving invalid slots untouched for the
+     * validator to reject with a useful message.
+     *
+     * @param  array<int, mixed>  $entrants
+     * @return array<int, mixed>
+     */
+    public static function normalizeEntrants(array $entrants): array
+    {
+        return array_map(function (mixed $slot): mixed {
+            if (! is_array($slot)) {
+                return $slot;
+            }
+
+            try {
+                return EntrantSlot::fromArray($slot)->toArray();
+            } catch (DomainException) {
+                return $slot;
+            }
+        }, array_values($entrants));
+    }
+
     protected function prepareForValidation(): void
     {
         $this->merge([
@@ -73,6 +131,12 @@ protected function prepareForValidation(): void
             unset($config['best_placed_count']);
         }
 
+        if (! empty($config['entrants']) && is_array($config['entrants']) && in_array($format, ['single_elimination', 'double_elimination'], true)) {
+            $config['entrants'] = self::normalizeEntrants($config['entrants']);
+        } else {
+            unset($config['entrants']);
+        }
+
         $this->merge([
             'config' => empty($config) ? null : $config,
         ]);
diff --git a/app/Http/Requests/UpdateStageRequest.php b/app/Http/Requests/UpdateStageRequest.php
index 2da19f5..8dbae1a 100644
--- a/app/Http/Requests/UpdateStageRequest.php
+++ b/app/Http/Requests/UpdateStageRequest.php
@@ -44,6 +44,7 @@ public function rules(): array
             'config' => ['nullable', 'array'],
             'config.legs_per_group' => ['sometimes', 'integer', 'in:1,2'],
             'config.best_placed_count' => ['sometimes', 'integer', 'min:1', 'max:16'],
+            'config.entrants' => ['sometimes', 'array', StoreStageRequest::entrantsRule()],
         ];
     }
 
@@ -69,6 +70,12 @@ protected function prepareForValidation(): void
             unset($config['best_placed_count']);
         }
 
+        if (! empty($config['entrants']) && is_array($config['entrants']) && in_array($format, ['single_elimination', 'double_elimination'], true)) {
+            $config['entrants'] = StoreStageRequest::normalizeEntrants($config['entrants']);
+        } else {
+            unset($config['entrants']);
+        }
+
         $this->merge([
             'config' => empty($config) ? null : $config,
         ]);
diff --git a/resources/js/components/Bracket.vue b/resources/js/components/Bracket.vue
index 4a71207..afc7246 100644
--- a/resources/js/components/Bracket.vue
+++ b/resources/js/components/Bracket.vue
@@ -13,6 +13,8 @@ interface BracketGame {
     bracket_position: number;
     home_team: TeamRef | null;
     away_team: TeamRef | null;
+    home_placeholder: string | null;
+    away_placeholder: string | null;
     home_team_score: number | null;
     away_team_score: number | null;
     status: string;
@@ -50,14 +52,18 @@ defineProps<{
                             class="flex items-center justify-between gap-2 border-b px-3 py-1.5 text-sm"
                             :class="game.winner === 'home' ? 'font-semibold' : 'text-muted-foreground'"
                         >
-                            <span class="truncate">{{ game.home_team?.name ?? 'TBD' }}</span>
+                            <span class="truncate" :class="{ 'italic opacity-70': !game.home_team && game.home_placeholder }">
+                                {{ game.home_team?.name ?? game.home_placeholder ?? 'TBD' }}
+                            </span>
                             <span class="tabular-nums">{{ game.home_team_score ?? '–' }}</span>
                         </div>
                         <div
                             class="flex items-center justify-between gap-2 px-3 py-1.5 text-sm"
                             :class="game.winner === 'away' ? 'font-semibold' : 'text-muted-foreground'"
                         >
-                            <span class="truncate">{{ game.away_team?.name ?? 'TBD' }}</span>
+                            <span class="truncate" :class="{ 'italic opacity-70': !game.away_team && game.away_placeholder }">
+                                {{ game.away_team?.name ?? game.away_placeholder ?? 'TBD' }}
+                            </span>
                             <span class="tabular-nums">{{ game.away_team_score ?? '–' }}</span>
                         </div>
                     </Link>
diff --git a/resources/js/pages/Stages/Edit.vue b/resources/js/pages/Stages/Edit.vue
index a297034..01f101e 100644
--- a/resources/js/pages/Stages/Edit.vue
+++ b/resources/js/pages/Stages/Edit.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import { Head, Link, useForm } from '@inertiajs/vue3';
-import { computed } from 'vue';
+import { computed, ref, watch } from 'vue';
 import Breadcrumbs from '@/components/Breadcrumbs.vue';
 import InputError from '@/components/InputError.vue';
 import { Button } from '@/components/ui/button';
@@ -39,11 +39,22 @@ interface FormatOption {
     label: string;
 }
 
+interface SourceStage {
+    id: number;
+    name: string;
+    advances_count: number;
+    best_placed_count: number;
+    groups: { id: number; name: string }[];
+}
+
+type Entrant = { type: 'group'; group: string; position: number } | { type: 'best_placed'; rank: number };
+
 const props = defineProps<{
     league: LeagueSummary;
     season: SeasonSummary;
     stage: Stage;
     formats: FormatOption[];
+    sourceStage: SourceStage | null;
 }>();
 
 const currentLegs = (props.stage.config?.legs_per_group as 1 | 2 | undefined) ?? 1;
@@ -58,10 +69,139 @@ const form = useForm({
     config: {
         legs_per_group: currentLegs,
         best_placed_count: currentBestPlaced,
+        entrants: (props.stage.config?.entrants as Entrant[] | undefined) ?? null,
     },
 });
 
 const hasGroupedFormat = ['group_stage', 'conference'].includes(props.stage.format);
+const isBracketFormat = ['single_elimination', 'double_elimination'].includes(props.stage.format);
+
+/*
+ * Knockout entrant builder. Slots are edited as string tokens
+ * ("group|Group A|1" / "best|3") so a <Select> can hold them, and mirrored
+ * into form.config.entrants as descriptor objects on every change.
+ */
+function tokenOf(entrant: Entrant): string {
+    return entrant.type === 'group' ? `group|${entrant.group}|${entrant.position}` : `best|${entrant.rank}`;
+}
+
+function entrantOf(token: string): Entrant {
+    const parts = token.split('|');
+
+    return parts[0] === 'best'
+        ? { type: 'best_placed', rank: Number(parts[1]) }
+        : { type: 'group', group: parts[1], position: Number(parts[2]) };
+}
+
+function positionLabel(position: number, group: string): string {
+    if (position === 1) return `Winner ${group}`;
+    if (position === 2) return `Runner-up ${group}`;
+
+    const suffix = position % 10 === 3 && position % 100 !== 13 ? 'rd' : 'th';
+
+    return `${position}${suffix} ${group}`;
+}
+
+const slotOptions = computed<{ value: string; label: string }[]>(() => {
+    if (!props.sourceStage) return [];
+
+    const options: { value: string; label: string }[] = [];
+
+    for (const group of props.sourceStage.groups) {
+        for (let position = 1; position <= props.sourceStage.advances_count; position++) {
+            options.push({ value: `group|${group.name}|${position}`, label: positionLabel(position, group.name) });
+        }
+    }
+
+    for (let rank = 1; rank <= props.sourceStage.best_placed_count; rank++) {
+        options.push({ value: `best|${rank}`, label: `Best-placed #${rank}` });
+    }
+
+    return options;
+});
+
+const qualifierTotal = computed(() => {
+    if (!props.sourceStage) return 0;
+
+    return props.sourceStage.groups.length * props.sourceStage.advances_count + props.sourceStage.best_placed_count;
+});
+
+const qualifierTotalIsPowerOfTwo = computed(() => qualifierTotal.value >= 2 && (qualifierTotal.value & (qualifierTotal.value - 1)) === 0);
+
+const entrantTokens = ref<string[]>(((props.stage.config?.entrants as Entrant[] | undefined) ?? []).map(tokenOf));
+
+watch(
+    entrantTokens,
+    (tokens) => {
+        form.config.entrants = tokens.length > 0 ? tokens.map(entrantOf) : null;
+    },
+    { deep: true },
+);
+
+/**
+ * Classic template for even group counts with exactly 2 qualifiers and no
+ * best-placed spots: 1A v 2B, 1C v 2D, …, then 1B v 2A, 1D v 2C, … so
+ * group-mates land in opposite bracket halves.
+ */
+const classicTemplateAvailable = computed(() => {
+    const src = props.sourceStage;
+
+    return !!src && src.best_placed_count === 0 && src.advances_count === 2 && src.groups.length >= 2 && src.groups.length % 2 === 0 && qualifierTotalIsPowerOfTwo.value;
+});
+
+function applyClassicTemplate(): void {
+    const groups = props.sourceStage!.groups.map((g) => g.name);
+    const firstHalf: string[] = [];
+    const secondHalf: string[] = [];
+
+    for (let i = 0; i < groups.length; i += 2) {
+        firstHalf.push(`group|${groups[i]}|1`, `group|${groups[i + 1]}|2`);
+        secondHalf.push(`group|${groups[i + 1]}|1`, `group|${groups[i]}|2`);
+    }
+
+    entrantTokens.value = [...firstHalf, ...secondHalf];
+}
+
+/**
+ * Seeded template for any qualifier shape totalling a power of two: group
+ * winners are the strongest seeds (in group order), then runners-up, then
+ * best-placed teams — laid out with standard bracket seeding so seeds 1
+ * and 2 can only meet in the final.
+ */
+function applySeededTemplate(): void {
+    const src = props.sourceStage!;
+    const seedList: string[] = [];
+
+    for (let position = 1; position <= src.advances_count; position++) {
+        for (const group of src.groups) {
+            seedList.push(`group|${group.name}|${position}`);
+        }
+    }
+
+    for (let rank = 1; rank <= src.best_placed_count; rank++) {
+        seedList.push(`best|${rank}`);
+    }
+
+    const rounds = Math.log2(seedList.length);
+    let seeds = [1, 2];
+
+    for (let round = 2; round <= rounds; round++) {
+        const size = 2 ** round;
+        const next: number[] = [];
+
+        for (const seed of seeds) {
+            next.push(seed, size + 1 - seed);
+        }
+
+        seeds = next;
+    }
+
+    entrantTokens.value = seeds.map((seed) => seedList[seed - 1]);
+}
+
+function clearEntrants(): void {
+    entrantTokens.value = [];
+}
 
 const formatLabel = props.formats.find((f) => f.value === props.stage.format)?.label ?? props.stage.format;
 
@@ -143,6 +283,66 @@ function submit() {
                 <InputError :message="form.errors['config.legs_per_group']" />
             </div>
 
+            <div v-if="isBracketFormat" class="grid gap-3 rounded-md border p-4">
+                <div>
+                    <h2 class="text-sm font-semibold">Knockout entrants</h2>
+                    <p class="text-xs text-muted-foreground">
+                        <template v-if="sourceStage">
+                            Which qualifier from "{{ sourceStage.name }}" fills each round-1 slot. Consecutive slots play each other.
+                            {{ sourceStage.groups.length }} groups × top {{ sourceStage.advances_count }}<template v-if="sourceStage.best_placed_count"> + {{ sourceStage.best_placed_count }} best-placed</template>
+                            = {{ qualifierTotal }} qualifiers.
+                        </template>
+                        <template v-else>
+                            No earlier grouped stage found in this season — entrants can be configured once one exists.
+                        </template>
+                    </p>
+                </div>
+
+                <template v-if="sourceStage">
+                    <div v-if="!qualifierTotalIsPowerOfTwo" class="rounded-md border border-amber-300 bg-amber-50 p-3 text-xs text-amber-900 dark:border-amber-700/40 dark:bg-amber-950/40 dark:text-amber-200">
+                        {{ qualifierTotal }} qualifiers can't fill a bracket — the total must be a power of two (2, 4, 8, 16, 32…).
+                        Adjust "Advance per group" or "Best-placed qualifiers" on the group stage.
+                    </div>
+
+                    <div class="flex flex-wrap gap-2">
+                        <Button v-if="classicTemplateAvailable" type="button" size="sm" variant="outline" @click="applyClassicTemplate">
+                            Classic template (1A v 2B …)
+                        </Button>
+                        <Button type="button" size="sm" variant="outline" :disabled="!qualifierTotalIsPowerOfTwo" @click="applySeededTemplate">
+                            Seeded template
+                        </Button>
+                        <Button v-if="entrantTokens.length > 0" type="button" size="sm" variant="ghost" class="text-destructive" @click="clearEntrants">
+                            Clear
+                        </Button>
+                    </div>
+
+                    <div v-if="entrantTokens.length > 0" class="grid gap-2">
+                        <div
+                            v-for="match in entrantTokens.length / 2"
+                            :key="match"
+                            class="flex flex-wrap items-center gap-2 rounded-md border bg-card px-3 py-2"
+                        >
+                            <span class="w-16 shrink-0 font-display text-xs font-semibold uppercase text-muted-foreground">Match {{ match }}</span>
+                            <Select v-model="entrantTokens[2 * (match - 1)]">
+                                <SelectTrigger class="h-8 w-56 text-xs"><SelectValue /></SelectTrigger>
+                                <SelectContent>
+                                    <SelectItem v-for="option in slotOptions" :key="option.value" :value="option.value">{{ option.label }}</SelectItem>
+                                </SelectContent>
+                            </Select>
+                            <span class="text-xs text-muted-foreground">vs</span>
+                            <Select v-model="entrantTokens[2 * (match - 1) + 1]">
+                                <SelectTrigger class="h-8 w-56 text-xs"><SelectValue /></SelectTrigger>
+                                <SelectContent>
+                                    <SelectItem v-for="option in slotOptions" :key="option.value" :value="option.value">{{ option.label }}</SelectItem>
+                                </SelectContent>
+                            </Select>
+                        </div>
+                    </div>
+
+                    <InputError :message="form.errors['config.entrants']" />
+                </template>
+            </div>
+
             <div v-if="hasGroupedFormat" class="grid grid-cols-1 gap-5 sm:grid-cols-2">
                 <div class="grid gap-2">
                     <Label for="advances_count">Advance per group (optional)</Label>
diff --git a/tests/Feature/Stages/StageEntrantsTest.php b/tests/Feature/Stages/StageEntrantsTest.php
new file mode 100644
index 0000000..4093270
--- /dev/null
+++ b/tests/Feature/Stages/StageEntrantsTest.php
@@ -0,0 +1,182 @@
+<?php
+
+use App\Actions\GenerateFixtures;
+use App\Enums\StageFormat;
+use App\Models\Group;
+use App\Models\League;
+use App\Models\Season;
+use App\Models\Stage;
+
+/**
+ * Build a public league + season with a completed-shape group stage (2 groups)
+ * and a knockout stage after it. Returns [league, season, groupStage, knockout].
+ *
+ * @param  array<string, mixed>  $knockoutAttributes
+ * @return array{0: League, 1: Season, 2: Stage, 3: Stage}
+ */
+function knockoutScaffold(array $knockoutAttributes = []): array
+{
+    $league = League::factory()->create(['is_public' => true]);
+    $season = Season::factory()->create(['league_id' => $league->id]);
+
+    $groupStage = Stage::factory()->groupStage()->create([
+        'season_id' => $season->id,
+        'name' => 'Groups',
+        'order' => 10,
+        'advances_count' => 2,
+    ]);
+
+    Group::factory()->create(['stage_id' => $groupStage->id, 'name' => 'Group A', 'order' => 0]);
+    Group::factory()->create(['stage_id' => $groupStage->id, 'name' => 'Group B', 'order' => 1]);
+
+    $knockout = Stage::factory()->singleElimination()->create([
+        'season_id' => $season->id,
+        'name' => 'Knockout',
+        'order' => 20,
+        ...$knockoutAttributes,
+    ]);
+
+    return [$league, $season, $groupStage, $knockout];
+}
+
+/**
+ * The classic 2-group entrant template: 1A v 2B, 1B v 2A.
+ *
+ * @return array<int, array<string, mixed>>
+ */
+function classicFourEntrants(): array
+{
+    return [
+        ['type' => 'group', 'group' => 'Group A', 'position' => 1],
+        ['type' => 'group', 'group' => 'Group B', 'position' => 2],
+        ['type' => 'group', 'group' => 'Group B', 'position' => 1],
+        ['type' => 'group', 'group' => 'Group A', 'position' => 2],
+    ];
+}
+
+describe('Stage config.entrants validation', function () {
+    it('accepts a valid entrant list on a knockout stage', function () {
+        [$league, $season, , $knockout] = knockoutScaffold();
+
+        $this->actingAs($league->owner)
+            ->put("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$knockout->id}", [
+                'name' => $knockout->name,
+                'config' => ['entrants' => classicFourEntrants()],
+            ])
+            ->assertRedirect()
+            ->assertSessionDoesntHaveErrors();
+
+        expect($knockout->fresh()->config['entrants'])->toBe(classicFourEntrants());
+    });
+
+    it('rejects an entrant count that is not a power of two', function () {
+        [$league, $season, , $knockout] = knockoutScaffold();
+
+        $this->actingAs($league->owner)
+            ->put("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$knockout->id}", [
+                'name' => $knockout->name,
+                'config' => ['entrants' => array_slice(classicFourEntrants(), 0, 3)],
+            ])
+            ->assertSessionHasErrors('config.entrants');
+    });
+
+    it('rejects malformed slot descriptors', function () {
+        [$league, $season, , $knockout] = knockoutScaffold();
+
+        $this->actingAs($league->owner)
+            ->put("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$knockout->id}", [
+                'name' => $knockout->name,
+                'config' => ['entrants' => [
+                    ['type' => 'group', 'group' => 'Group A', 'position' => 1],
+                    ['type' => 'wildcard'],
+                ]],
+            ])
+            ->assertSessionHasErrors('config.entrants');
+    });
+
+    it('silently drops entrants for non-bracket formats', function () {
+        $league = League::factory()->create();
+        $season = Season::factory()->create(['league_id' => $league->id]);
+
+        $this->actingAs($league->owner)
+            ->post("/leagues/{$league->slug}/seasons/{$season->id}/stages", [
+                'name' => 'Groups',
+                'format' => StageFormat::GroupStage->value,
+                'config' => ['entrants' => classicFourEntrants()],
+            ])
+            ->assertRedirect();
+
+        expect(Stage::where('name', 'Groups')->firstOrFail()->config)->toBeNull();
+    });
+});
+
+describe('Entrant-driven fixture generation and bracket placeholders', function () {
+    it('generates an all-TBD bracket from the entrant list', function () {
+        [, , , $knockout] = knockoutScaffold([
+            'config' => ['entrants' => classicFourEntrants()],
+        ]);
+
+        $games = app(GenerateFixtures::class)->execute($knockout->fresh('season.teams'));
+
+        expect($games)->toHaveCount(3);
+        expect($games->every(fn ($game) => $game->home_team_id === null && $game->away_team_id === null))->toBeTrue();
+    });
+
+    it('labels unfilled round-1 slots with their entrant descriptors', function () {
+        [$league, $season, , $knockout] = knockoutScaffold([
+            'config' => ['entrants' => classicFourEntrants()],
+        ]);
+
+        app(GenerateFixtures::class)->execute($knockout->fresh('season.teams'));
+
+        $this->get("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$knockout->id}")
+            ->assertSuccessful()
+            ->assertInertia(fn ($page) => $page
+                ->where('bracket.0.games.0.home_placeholder', 'Winner Group A')
+                ->where('bracket.0.games.0.away_placeholder', 'Runner-up Group B')
+                ->where('bracket.0.games.1.home_placeholder', 'Winner Group B')
+                ->where('bracket.0.games.1.away_placeholder', 'Runner-up Group A')
+                ->where('bracket.1.games.0.home_placeholder', null)
+                ->where('bracket.1.games.0.away_placeholder', null)
+            );
+    });
+});
+
+describe('Stage edit sourceStage prop', function () {
+    it('exposes the previous grouped stage to the entrant builder', function () {
+        [$league, $season, $groupStage, $knockout] = knockoutScaffold();
+
+        $groupStage->update(['config' => ['best_placed_count' => 2]]);
+
+        $this->actingAs($league->owner)
+            ->get("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$knockout->id}/edit")
+            ->assertSuccessful()
+            ->assertInertia(fn ($page) => $page
+                ->where('sourceStage.id', $groupStage->id)
+                ->where('sourceStage.advances_count', 2)
+                ->where('sourceStage.best_placed_count', 2)
+                ->where('sourceStage.groups.0.name', 'Group A')
+                ->where('sourceStage.groups.1.name', 'Group B')
+            );
+    });
+
+    it('is null for non-bracket stages and when no grouped stage precedes', function () {
+        [$league, $season, $groupStage] = knockoutScaffold();
+
+        $this->actingAs($league->owner)
+            ->get("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$groupStage->id}/edit")
+            ->assertSuccessful()
+            ->assertInertia(fn ($page) => $page->where('sourceStage', null));
+
+        $earlyKnockout = Stage::factory()->singleElimination()->create([
+            'season_id' => $season->id,
+            'name' => 'Play-in',
+            'order' => 5,
+        ]);
+
+        $this->actingAs($league->owner)
+            ->get("/leagues/{$league->slug}/seasons/{$season->id}/stages/{$earlyKnockout->id}/edit")
+            ->assertSuccessful()
+            ->assertInertia(fn ($page) => $page->where('sourceStage', null));
+    });
+});
diff --git a/tests/Unit/Formats/EntrantSlotTest.php b/tests/Unit/Formats/EntrantSlotTest.php
new file mode 100644
index 0000000..0d60e51
--- /dev/null
+++ b/tests/Unit/Formats/EntrantSlotTest.php
@@ -0,0 +1,38 @@
+<?php
+
+use App\Domain\Formats\EntrantSlot;
+
+describe('EntrantSlot', function () {
+    it('labels group slots by finishing position', function (int $position, string $expected) {
+        $slot = EntrantSlot::fromArray(['type' => 'group', 'group' => 'Group A', 'position' => $position]);
+
+        expect($slot->label())->toBe($expected);
+    })->with([
+        'winner' => [1, 'Winner Group A'],
+        'runner-up' => [2, 'Runner-up Group A'],
+        'third' => [3, '3rd Group A'],
+        'fourth' => [4, '4th Group A'],
+    ]);
+
+    it('labels best-placed slots by rank', function () {
+        $slot = EntrantSlot::fromArray(['type' => 'best_placed', 'rank' => 4]);
+
+        expect($slot->label())->toBe('Best-placed #4');
+    });
+
+    it('normalizes string numbers and drops extraneous keys in toArray', function () {
+        $slot = EntrantSlot::fromArray(['type' => 'group', 'group' => 'Group B', 'position' => '2', 'junk' => true]);
+
+        expect($slot->toArray())->toBe(['type' => 'group', 'group' => 'Group B', 'position' => 2]);
+    });
+
+    it('rejects malformed slots', function (array $raw) {
+        EntrantSlot::fromArray($raw);
+    })->with([
+        'unknown type' => [['type' => 'wildcard', 'rank' => 1]],
+        'group without name' => [['type' => 'group', 'position' => 1]],
+        'group position zero' => [['type' => 'group', 'group' => 'Group A', 'position' => 0]],
+        'best placed without rank' => [['type' => 'best_placed']],
+        'best placed rank zero' => [['type' => 'best_placed', 'rank' => 0]],
+    ])->throws(DomainException::class);
+});
diff --git a/tests/Unit/Formats/SingleEliminationGeneratorTest.php b/tests/Unit/Formats/SingleEliminationGeneratorTest.php
index f8b8cc9..ed42a37 100644
--- a/tests/Unit/Formats/SingleEliminationGeneratorTest.php
+++ b/tests/Unit/Formats/SingleEliminationGeneratorTest.php
@@ -127,3 +127,47 @@ function roundOne(Collection $pairs): Collection
         }
     });
 });
+
+describe('SingleEliminationGenerator (entrant mode)', function () {
+    function stageWithEntrants(int $slotCount): Stage
+    {
+        $entrants = [];
+        for ($i = 0; $i < $slotCount; $i++) {
+            $entrants[] = ['type' => 'best_placed', 'rank' => $i + 1];
+        }
+
+        $season = Season::factory()->create();
+
+        return Stage::factory()->singleElimination()->create([
+            'season_id' => $season->id,
+            'config' => ['entrants' => $entrants],
+        ]);
+    }
+
+    it('emits an all-TBD bracket sized to the entrant list, ignoring season teams', function () {
+        $stage = stageWithEntrants(8);
+        $stage->season->teams()->attach(Team::factory()->count(3)->create());
+
+        $pairs = (new SingleEliminationGenerator)->generate($stage->fresh('season.teams'));
+
+        expect($pairs)->toHaveCount(7); // 4 + 2 + 1
+        expect(roundOne($pairs))->toHaveCount(4);
+
+        foreach ($pairs as $pair) {
+            expect($pair['home_team_id'])->toBeNull();
+            expect($pair['away_team_id'])->toBeNull();
+        }
+    });
+
+    it('lays out sequential bracket positions per round', function () {
+        $pairs = (new SingleEliminationGenerator)->generate(stageWithEntrants(8));
+
+        expect(roundOne($pairs)->pluck('bracket_position')->all())->toBe([0, 1, 2, 3]);
+        expect($pairs->where('round', 2)->pluck('bracket_position')->values()->all())->toBe([0, 1]);
+        expect($pairs->where('round', 3)->pluck('bracket_position')->values()->all())->toBe([0]);
+    });
+
+    it('rejects an entrant count that is not a power of two', function () {
+        (new SingleEliminationGenerator)->generate(stageWithEntrants(6));
+    })->throws(DomainException::class);
+});