diff --git a/frontend/src/index.css b/frontend/src/index.css
index 6a926b2..f735f21 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -204,6 +204,11 @@ body {
 	}
 }
 
+/* Standings: rows keep their identity, so the list re-orders as a move, not a repaint. */
+.rank-move {
+	transition: transform 0.8s cubic-bezier(0.22, 1, 0.36, 1);
+}
+
 /* The avatar strip says "this scrolls" with faces cut off at the gutter, so
    the bar underneath is noise. */
 .no-scrollbar {
diff --git a/frontend/src/pages/Host.vue b/frontend/src/pages/Host.vue
index 386137d..9965ba1 100644
--- a/frontend/src/pages/Host.vue
+++ b/frontend/src/pages/Host.vue
@@ -233,6 +233,88 @@
 			</div>
 		</template>
 
+		<!-- Scoreboard: the points land, then the rows climb to their new places -->
+		<template v-else-if="phase === 'scoreboard'">
+			<div
+				class="flex min-h-0 flex-1 flex-col items-center justify-center gap-6 p-5 sm:gap-8 sm:p-8"
+			>
+				<div class="text-center">
+					<p class="font-mono text-xs uppercase tracking-[0.28em] text-paper/40">
+						After question {{ (scoreboard?.q_index ?? 0) + 1 }} of
+						{{ scoreboard?.total }}
+					</p>
+					<h1 class="mt-2 font-display text-4xl font-extrabold text-paper sm:text-6xl">
+						Scoreboard
+					</h1>
+				</div>
+
+				<TransitionGroup
+					tag="ol"
+					name="rank"
+					class="flex min-h-0 w-full max-w-3xl flex-col gap-2.5 overflow-y-auto p-1"
+				>
+					<li
+						v-for="(entry, place) in standings"
+						:key="entry.nickname"
+						class="flex items-center gap-4 rounded-2xl border bg-dusk px-4 py-3 sm:px-5 sm:py-4"
+						:class="settled && entry.rank === 1 ? 'border-accent' : 'border-haze'"
+					>
+						<!-- until the rows land, the number is where the row sits, not the rank it
+						     came from: a top five missing a player who fell out of it would gap -->
+						<span class="w-6 shrink-0 font-mono text-lg tabular-nums text-paper/35">
+							{{ settled ? entry.rank : place + 1 }}
+						</span>
+						<AvatarPic :id="entry.avatar" :nickname="entry.nickname" :size="44" />
+						<span
+							class="min-w-0 flex-1 truncate font-display text-xl font-bold text-paper sm:text-2xl"
+						>
+							{{ entry.nickname }}
+						</span>
+						<span
+							v-if="entry.gained"
+							class="font-mono text-base font-bold text-ok transition-opacity duration-500 sm:text-lg"
+							:class="settled ? 'opacity-0' : 'opacity-100'"
+						>
+							+{{ entry.gained }}
+						</span>
+						<span
+							class="w-24 shrink-0 text-right font-mono text-xl font-bold tabular-nums text-accent sm:text-2xl"
+						>
+							{{ shownScores[entry.nickname] ?? entry.score }}
+						</span>
+					</li>
+				</TransitionGroup>
+
+				<ul
+					v-if="streaks.length"
+					class="flex flex-wrap justify-center gap-x-6 gap-y-2 text-base text-paper/70 sm:text-lg"
+				>
+					<li
+						v-for="entry in streaks"
+						:key="entry.nickname"
+						class="flex items-center gap-2"
+					>
+						<AvatarPic :id="entry.avatar" :nickname="entry.nickname" :size="28" />
+						🔥 {{ entry.nickname }} is on a {{ entry.streak }} answer streak
+					</li>
+				</ul>
+
+				<div class="flex flex-wrap items-center justify-center gap-3">
+					<button class="ctl ctl-go" @click="next">Next question</button>
+					<button
+						v-if="showHostControls"
+						class="ctl"
+						:data-on="autoAdvance"
+						@click="toggleAutoAdvance"
+					>
+						Auto-advance {{ autoAdvance ? "on" : "off" }}
+					</button>
+					<button v-if="showHostControls" class="ctl" @click="end">End game</button>
+					<p v-if="error" class="text-alert">{{ error }}</p>
+				</div>
+			</div>
+		</template>
+
 		<!-- Read time: question only, no answers yet -->
 		<template v-else-if="phase === 'get_ready'">
 			<div
@@ -285,7 +367,7 @@
 					/>
 					<div class="flex flex-wrap items-center justify-center gap-3">
 						<button class="ctl ctl-go" @click="next">
-							{{ explanation?.before_stats ? "Show results" : "Next question" }}
+							{{ explanation?.before_stats ? "Show results" : afterQuestionLabel }}
 						</button>
 						<button
 							v-if="showHostControls"
@@ -369,48 +451,6 @@
 								</div>
 							</div>
 						</div>
-
-						<div class="flex flex-wrap items-start justify-between gap-6 sm:gap-8">
-							<ol class="w-full flex-1 sm:min-w-64">
-								<li
-									v-for="(entry, index) in top5"
-									:key="entry.nickname"
-									class="flex items-center justify-between gap-3 border-b border-haze py-2 text-base text-paper/70 sm:text-lg"
-								>
-									<span class="flex min-w-0 items-center gap-3">
-										<span
-											class="w-5 shrink-0 font-mono text-xs tabular-nums text-paper/35"
-										>
-											{{ index + 1 }}
-										</span>
-										<AvatarPic
-											:id="entry.avatar"
-											:nickname="entry.nickname"
-											:size="28"
-										/>
-										<span class="truncate">{{ entry.nickname }}</span>
-									</span>
-									<span class="shrink-0 font-mono tabular-nums">{{
-										entry.score
-									}}</span>
-								</li>
-							</ol>
-							<ul class="w-full flex-1 space-y-2 text-base text-paper/70 sm:text-lg">
-								<li
-									v-for="entry in streaks"
-									:key="entry.nickname"
-									class="flex items-center gap-2"
-								>
-									<AvatarPic
-										:id="entry.avatar"
-										:nickname="entry.nickname"
-										:size="28"
-									/>
-									🔥 {{ entry.nickname }} is on a {{ entry.streak }} answer
-									streak
-								</li>
-							</ul>
-						</div>
 					</template>
 
 					<div class="flex flex-wrap items-center gap-3">
@@ -422,7 +462,7 @@
 							Skip
 						</button>
 						<button v-if="phase === 'closed'" class="ctl ctl-go" @click="next">
-							{{ explanationNext ? "Show explanation" : "Next question" }}
+							{{ explanationNext ? "Show explanation" : afterQuestionLabel }}
 						</button>
 						<button
 							v-if="showHostControls"
@@ -442,7 +482,7 @@
 </template>
 
 <script setup>
-import { computed, inject, onMounted, ref, watch } from "vue";
+import { computed, inject, onMounted, onUnmounted, ref, watch } from "vue";
 import QRCode from "qrcode";
 import { call, readError } from "@/api";
 import { confirm } from "@/confirm";
@@ -457,8 +497,12 @@ import { initSound, muted, playCue, toggleMute } from "@/sound";
 const PODIUM_FILL = { 1: "bg-gold", 2: "bg-lagoon", 3: "bg-orchid" };
 // remembered so a reload on the podium restores it: get_host_state only auto-finds live sessions
 const HOSTED_SESSION_KEY = "qz_hosted_session";
+// long enough to read the old order before it moves, and to watch the points climb
+const CLIMB_DELAY_MS = 700;
+const TALLY_MS = 900;
 
 const socket = inject("$socket");
+let climbTimer = null;
 const {
 	remaining,
 	total: windowSeconds,
@@ -480,8 +524,11 @@ const distribution = ref({});
 const explanation = ref(null);
 const explanationNext = ref(false);
 const correctOption = ref(null);
-const top5 = ref([]);
 const streaks = ref([]);
+const scoreboard = ref(null);
+const standings = ref([]);
+const shownScores = ref({});
+const settled = ref(false);
 const leaderboard = ref([]);
 const qrDataUrl = ref("");
 const qrFullscreen = ref(false);
@@ -522,6 +569,13 @@ const barHeight = (optionId) => {
 	return Math.max(3, ((distribution.value[optionId] || 0) / max) * 100);
 };
 
+// After the last question there is nothing left to stand on but the podium.
+const afterQuestionLabel = computed(() =>
+	(question.value?.q_index ?? 0) >= (question.value?.total ?? 1) - 1
+		? "Final results"
+		: "Show scores"
+);
+
 // 2nd, 1st, 3rd — the winner stands in the middle
 const podiumOrder = computed(() =>
 	[leaderboard.value[1], leaderboard.value[0], leaderboard.value[2]].filter(Boolean)
@@ -556,9 +610,10 @@ function onSessionEvent(message) {
 		explanationNext.value = Boolean(message.explanation_next);
 		distribution.value = message.distribution;
 		correctOption.value = message.correct_option;
-		top5.value = message.top_5;
-		streaks.value = message.streaks;
 		phase.value = "closed";
+	} else if (message.type === "scoreboard") {
+		stopCountdown();
+		showScoreboard(message);
 	} else if (message.type === "podium") {
 		stopCountdown();
 		leaderboard.value = message.leaderboard;
@@ -567,6 +622,46 @@ function onSessionEvent(message) {
 	}
 }
 
+// The screen opens on the standings the room already knows, then the points land and
+// the rows race to where they belong. `animate` is off on a reload: nothing to replay.
+function showScoreboard(message, animate = true) {
+	const entries = message.standings || [];
+	clearTimeout(climbTimer);
+	scoreboard.value = message;
+	streaks.value = message.streaks || [];
+	standings.value = byRank(entries, animate ? "previous_rank" : "rank");
+	shownScores.value = scoresAt(
+		entries,
+		animate ? (entry) => entry.score - entry.gained : (entry) => entry.score
+	);
+	settled.value = !animate;
+	phase.value = "scoreboard";
+	if (!animate) return;
+	climbTimer = setTimeout(() => {
+		standings.value = byRank(entries, "rank");
+		tallyScores(entries);
+	}, CLIMB_DELAY_MS);
+}
+
+const byRank = (entries, key) => [...entries].sort((a, b) => a[key] - b[key]);
+
+const scoresAt = (entries, score) =>
+	Object.fromEntries(entries.map((entry) => [entry.nickname, score(entry)]));
+
+function tallyScores(entries) {
+	const start = performance.now();
+	const step = (now) => {
+		const progress = Math.min(1, (now - start) / TALLY_MS);
+		const eased = 1 - Math.pow(1 - progress, 3);
+		shownScores.value = scoresAt(entries, (entry) =>
+			Math.round(entry.score - entry.gained * (1 - eased))
+		);
+		if (progress < 1) requestAnimationFrame(step);
+		else settled.value = true;
+	};
+	requestAnimationFrame(step);
+}
+
 // Level H redundancy is what buys the room to punch the logo over the middle.
 async function renderQr(url) {
 	const canvas = document.createElement("canvas");
@@ -610,7 +705,6 @@ async function applyState(state) {
 	lobbyLocked.value = Boolean(state.lobby_locked);
 	autoAdvance.value = Boolean(state.auto_advance);
 	showHostControls.value = Boolean(state.show_host_controls);
-	top5.value = state.top_5 || [];
 	qrDataUrl.value = await renderQr(joinUrl.value);
 
 	if (state.status === "Lobby") {
@@ -631,6 +725,8 @@ async function applyState(state) {
 		correctOption.value = state.question.correct_option;
 		phase.value = "explanation";
 		if (autoAdvance.value) startCountdown(state.remaining_seconds);
+	} else if (state.phase === "scoreboard") {
+		showScoreboard(state.scoreboard, false);
 	} else if (state.phase === "closed") {
 		question.value = state.question;
 		distribution.value = state.distribution || {};
@@ -744,6 +840,8 @@ async function end() {
 	if ((await hostCall("quizzly.api.end_session")) && inLobby) reset();
 }
 
+onUnmounted(() => clearTimeout(climbTimer));
+
 function reset() {
 	localStorage.removeItem(HOSTED_SESSION_KEY);
 	window.location.reload();
diff --git a/frontend/src/pages/Play.vue b/frontend/src/pages/Play.vue
index 8758d64..ff0768f 100644
--- a/frontend/src/pages/Play.vue
+++ b/frontend/src/pages/Play.vue
@@ -411,7 +411,7 @@ async function restore() {
 			phase.value = "locked";
 			stopCountdown();
 		}
-	} else if (state.phase === "closed" || state.phase === "explanation") {
+	} else if (["closed", "explanation", "scoreboard"].includes(state.phase)) {
 		explanation.value = state.explanation || null;
 		await showResult({ question_row: state.question.question_row });
 	} else {
diff --git a/progress.md b/progress.md
index e19fa84..d6dcbc7 100644
--- a/progress.md
+++ b/progress.md
@@ -1,5 +1,47 @@
 # Progress
 
+## Phase 12: Scoreboard screen (2026-08-22)
+
+Spec: `specs/phase-12-scoreboard-screen.md`. The screen that ends a question is
+now two: the answer split, then the standings.
+
+### Done
+
+- `engine.py`: new `scoreboard` phase, always the last beat before the next
+  question, whichever side the explanation sits on. `close_question` builds the
+  standings (score, points won, new rank, previous rank) and parks them in Redis
+  state; `carry_over` hands them through the phases in between untouched. The
+  last question skips the screen: the podium is the standings.
+- The top five and the streak callouts move off the stats payload onto the
+  scoreboard one. The stats screen is the distribution alone now.
+- `get_host_state` returns the parked standings for a reload during the phase,
+  and drops the `top_5` nothing read any more.
+- `Host.vue`: standings screen. Rows open in the old order with the old scores,
+  then the points count up on every row while the rows move to their new places.
+  `TransitionGroup` keyed by nickname does the move, so row identity survives the
+  re-sort. The rank column reads as list position until the rows land, or a
+  player who fell out of the top five leaves a gap in the numbering.
+- Reload during the phase paints the settled board with no replay.
+
+### Verified
+
+E2E on `quizzly.localhost` at 1920x1080, six players answering over the API, a
+real worker driving the loop:
+
+- Question closes to the distribution bars alone, `Show scores` moves on.
+- Standings open in the previous order at the previous scores, `+974` chips land
+  and the rows overtake: ann and eve climb from 4th and 5th past cid, bob, dee.
+- Host reload mid-standings comes back to the same five rows, settled.
+- Last question's button reads `Final results` and goes straight to the podium.
+
+### Notes
+
+- Engine tests cover the new phase both ways round the explanation and the
+  last-question skip: 31 green in `tests/test_engine.py`, plus api/game_ux green.
+- A dev-bench aside, not this app: the single bench worker serves `long` after
+  `default`, so a five-minute job from another site can starve the ticker and the
+  game abandons itself. The host reload settles it, as designed.
+
 ## Phase 11: Quiz preview (2026-08-20)
 
 Spec: `specs/phase-11-quiz-preview.md`. Preview in the editor plays the quiz
diff --git a/quizzly/api.py b/quizzly/api.py
index d14ce32..86964bc 100644
--- a/quizzly/api.py
+++ b/quizzly/api.py
@@ -81,12 +81,9 @@ def get_host_state(session: str | None = None) -> dict:
 	if session_doc.status == "Lobby":
 		return result
 
-	leaderboard = get_leaderboard(session_doc.name)
-	result["top_5"] = leaderboard[:5]
-
 	state = engine.get_state(session_doc.name)
 	if not state:
-		result["leaderboard"] = leaderboard
+		result["leaderboard"] = get_leaderboard(session_doc.name)
 		return result
 
 	question = get_question_row(session_doc, state["question_row"])
@@ -116,6 +113,8 @@ def get_host_state(session: str | None = None) -> dict:
 			distribution[str(answer.selected_option)] += 1
 		result["distribution"] = distribution
 		result["explanation_next"] = bool(state.get("explanation_after"))
+	if state["status"] == "scoreboard":
+		result["scoreboard"] = state["scoreboard"]
 	return result
 
 
diff --git a/quizzly/engine.py b/quizzly/engine.py
index f5edeec..7403671 100644
--- a/quizzly/engine.py
+++ b/quizzly/engine.py
@@ -14,6 +14,7 @@
 
 GRACE_SECONDS = 1.0
 STATS_SECONDS = 5
+SCOREBOARD_SECONDS = 5
 GETREADY_SECONDS = 3
 EXPLANATION_SECONDS = 10
 # ponytail: host gets 5 minutes to hit Next, then the game moves on by itself
@@ -136,13 +137,16 @@ def advance_session(session_doc, state: dict, control: str | None) -> None:
 			if state.get("closed_payload"):
 				show_stats(session_doc, state, state["closed_payload"])
 			else:
-				next_question(session_doc, questions, index, total)
+				show_standings(session_doc, state, questions, index, total)
 	elif phase == "stats":
 		if due or control == "advance":
 			if state.get("explanation_after"):
 				show_explanation(session_doc, state, state["explanation_after"])
 			else:
-				next_question(session_doc, questions, index, total)
+				show_standings(session_doc, state, questions, index, total)
+	elif phase == "scoreboard":
+		if due or control == "advance":
+			next_question(session_doc, questions, index, total)
 
 
 def next_question(session_doc, questions, index: int, total: int) -> None:
@@ -219,12 +223,14 @@ def close_question(session_doc, question, index: int, total: int) -> None:
 	distribution = {"1": 0, "2": 0, "3": 0, "4": 0}
 	answer_updates = {}
 	participant_updates = {}
+	gained = {}
 
 	for participant in participants:
 		answer = answer_by_participant.get(participant.name)
 		if not answer:
 			participant.streak = 0
 			participant_updates[participant.name] = {"streak": 0}
+			gained[participant.name] = 0
 			continue
 		distribution[str(answer.selected_option)] += 1
 		is_correct = str(answer.selected_option) == str(question.correct_option)
@@ -237,16 +243,13 @@ def close_question(session_doc, question, index: int, total: int) -> None:
 			participant.streak = 0
 			points = 0
 		participant.score += points
+		gained[participant.name] = points
 		answer_updates[answer.name] = {"is_correct": int(is_correct), "points": points}
 		participant_updates[participant.name] = {"score": participant.score, "streak": participant.streak}
 
 	frappe.db.bulk_update("QZ Answer", answer_updates)
 	frappe.db.bulk_update("QZ Participant", participant_updates)
 
-	top_5 = [
-		{"nickname": p.nickname, "avatar": p.avatar, "score": p.score}
-		for p in sorted(participants, key=lambda p: -p.score)[:5]
-	]
 	streaks = [
 		{"nickname": p.nickname, "avatar": p.avatar, "streak": p.streak}
 		for p in sorted(participants, key=lambda p: -p.streak)
@@ -259,10 +262,19 @@ def close_question(session_doc, question, index: int, total: int) -> None:
 		"question_row": question.name,
 		"correct_option": question.correct_option,
 		"distribution": distribution,
-		"top_5": top_5,
-		"streaks": streaks,
 		"is_last": index == total - 1,
 	}
+	# parked in state so every later phase can hand it on until the standings screen
+	state = {
+		**state,
+		"scoreboard": {
+			"type": "scoreboard",
+			"q_index": index,
+			"total": total,
+			"standings": build_standings(participants, gained),
+			"streaks": streaks,
+		},
+	}
 	frappe.cache.delete_value(answered_key(session_doc.name, question.name))
 
 	explanation = explanation_payload(session_doc, question, index, total)
@@ -312,6 +324,48 @@ def show_stats(session_doc, state: dict, closed: dict, explanation_after: dict |
 	publish_session_event(session_doc, {**closed, "explanation_next": bool(explanation_after)})
 
 
+def show_standings(session_doc, state: dict, questions, index: int, total: int) -> None:
+	"""Standings are the last beat of a question. On the last one the podium says it better."""
+	scoreboard = state.get("scoreboard")
+	if scoreboard and index < total - 1:
+		show_scoreboard(session_doc, state, scoreboard)
+	else:
+		next_question(session_doc, questions, index, total)
+
+
+def show_scoreboard(session_doc, state: dict, scoreboard: dict) -> None:
+	"""Who is where now, and where they were before the points landed."""
+	next_ts = time.time() + hold_seconds(session_doc, SCOREBOARD_SECONDS)
+	set_state(
+		session_doc.name,
+		{**carry_over(state), "phase": "scoreboard", "status": "scoreboard", "next_ts": next_ts},
+		ttl=ADVANCE_WAIT_CAP + STATE_TTL_MARGIN,
+	)
+	publish_session_event(session_doc, scoreboard)
+
+
+def build_standings(participants: list, gained: dict, top: int = 5) -> list[dict]:
+	"""Both places every row has to be in: the one it starts the screen at and the one it
+	climbs to. Ties break on join time, the same way the podium ranks them."""
+
+	def in_order(score_of):
+		return sorted(participants, key=lambda p: (-score_of(p), p.joined_at or now_datetime()))
+
+	before = in_order(lambda p: p.score - gained.get(p.name, 0))
+	previous_rank = {p.name: rank for rank, p in enumerate(before, start=1)}
+	return [
+		{
+			"nickname": p.nickname,
+			"avatar": p.avatar,
+			"score": p.score,
+			"gained": gained.get(p.name, 0),
+			"rank": rank,
+			"previous_rank": previous_rank[p.name],
+		}
+		for rank, p in enumerate(in_order(lambda p: p.score), start=1)
+	][:top]
+
+
 def carry_over(state: dict) -> dict:
 	"""Whatever a phase parked for the next one is that phase's business, never the one after."""
 	return {k: v for k, v in state.items() if k not in ("explanation", "closed_payload", "explanation_after")}
diff --git a/quizzly/tests/test_engine.py b/quizzly/tests/test_engine.py
index 6f10952..c564f0c 100644
--- a/quizzly/tests/test_engine.py
+++ b/quizzly/tests/test_engine.py
@@ -96,6 +96,13 @@ def activate(self):
 		frappe.db.set_value("QZ Session", self.session, "status", "Active")
 		self.session_doc.reload()
 
+	def record_events(self, events):
+		def record(event=None, message=None, room=None, **kwargs):
+			if isinstance(message, dict) and "type" in message:
+				events.append(message)
+
+		return record
+
 	def open_question(self, index=0, window=30):
 		question = self.questions[index]
 		now = time.time()
@@ -238,6 +245,7 @@ def test_full_game_to_podium(self):
 				"get_ready",
 				"question",
 				"question_closed",
+				"scoreboard",
 				"get_ready",
 				"question",
 				"question_closed",
@@ -251,7 +259,10 @@ def test_full_game_to_podium(self):
 		first_closed = next(e for e in events if e["type"] == "question_closed")
 		self.assertEqual(first_closed["correct_option"], "2")
 		self.assertEqual(first_closed["distribution"], {"1": 0, "2": 1, "3": 1, "4": 0})
-		self.assertEqual(first_closed["top_5"][0]["nickname"], "alice")
+
+		scoreboard = next(e for e in events if e["type"] == "scoreboard")
+		self.assertEqual([s["nickname"] for s in scoreboard["standings"]], ["alice", "bob"])
+		self.assertGreater(scoreboard["standings"][0]["gained"], 0)
 
 		podium = events[-1]
 		self.assertEqual(podium["type"], "podium")
@@ -305,6 +316,37 @@ def test_stats_holds_for_host_when_auto_advance_off(self):
 			engine.advance_session(self.session_doc, state, None)
 		self.assertEqual(engine.get_state(self.session)["phase"], "stats")
 
+	def test_stats_hands_over_to_the_standings_screen(self):
+		self.activate()
+		question = self.open_question(window=30)
+		submit_answer(self.pin, self.bob["participant_token"], question.name, "2")
+		events = []
+
+		with patch("frappe.publish_realtime", side_effect=self.record_events(events)):
+			with patch("frappe.db.commit"):
+				engine.close_question(self.session_doc, question, 0, len(self.questions))
+				engine.advance_session(self.session_doc, engine.get_state(self.session), "advance")
+
+		self.assertEqual(engine.get_state(self.session)["phase"], "scoreboard")
+		self.assertEqual([e["type"] for e in events], ["question_closed", "scoreboard"])
+		standings = events[1]["standings"]
+		# bob answered his way past alice, so the screen has both places to move between
+		self.assertEqual([s["nickname"] for s in standings], ["bob", "alice"])
+		self.assertEqual([s["rank"] for s in standings], [1, 2])
+		self.assertEqual([s["previous_rank"] for s in standings], [2, 1])
+		self.assertEqual(standings[0]["gained"], standings[0]["score"])
+		self.assertEqual(standings[1]["gained"], 0)
+
+	def test_last_question_skips_the_standings_for_the_podium(self):
+		self.activate()
+		frappe.db.set_value("QZ Session", self.session, "auto_advance", 0)
+		last = len(self.questions) - 1
+		question = self.open_question(index=last)
+		with patch("frappe.publish_realtime"), patch("frappe.db.commit"):
+			engine.close_question(self.session_doc, question, last, len(self.questions))
+			engine.advance_session(self.session_doc, engine.get_state(self.session), "advance")
+		self.assertEqual(frappe.db.get_value("QZ Session", self.session, "status"), "Ended")
+
 	def test_advance_control_on_last_question_finishes(self):
 		self.activate()
 		frappe.db.set_value("QZ Session", self.session, "auto_advance", 0)
@@ -380,13 +422,6 @@ def enable_explanation(self, text="Canberra it is.", image=None):
 		quiz.save()
 		self.questions = frappe.get_doc("QZ Quiz", self.quiz.name).questions
 
-	def record_events(self, events):
-		def record(event=None, message=None, room=None, **kwargs):
-			if isinstance(message, dict) and "type" in message:
-				events.append(message)
-
-		return record
-
 	def test_explanation_holds_the_scoreboard_back(self):
 		self.activate()
 		self.enable_explanation()
@@ -437,10 +472,16 @@ def test_explanation_after_stats_reverses_the_two_screens(self):
 				state = engine.get_state(self.session)
 				self.assertEqual(state["phase"], "explanation")
 				self.assertFalse(state["explanation"]["before_stats"])
-				# nothing is owed to the room after it, so the next step is the next question
+				# nothing is owed to the room after it, so the standings close the question
+				engine.advance_session(self.session_doc, state, "advance")
+				state = engine.get_state(self.session)
+				self.assertEqual(state["phase"], "scoreboard")
 				engine.advance_session(self.session_doc, state, "advance")
 
-		self.assertEqual([e["type"] for e in events], ["question_closed", "explanation", "get_ready"])
+		self.assertEqual(
+			[e["type"] for e in events],
+			["question_closed", "explanation", "scoreboard", "get_ready"],
+		)
 		self.assertEqual(engine.get_state(self.session)["q_index"], 1)
 
 	def test_quiz_sets_how_long_the_explanation_stays_up(self):
diff --git a/specs/phase-12-scoreboard-screen.md b/specs/phase-12-scoreboard-screen.md
new file mode 100644
index 0000000..052a3d5
--- /dev/null
+++ b/specs/phase-12-scoreboard-screen.md
@@ -0,0 +1,82 @@
+# Phase 12: Scoreboard screen
+
+## Goal
+
+Split the one screen that ends a question into two. First the room sees **what
+everyone answered**. Then, on its own screen, it sees **who moved**: the points
+land on the rows and the rows climb or fall to their new places.
+
+Today both live on the stats screen: the distribution bars, the top five and the
+streak callouts share it, so the points arrive as a list that is already sorted.
+Nobody sees the overtake happen.
+
+## Tracer bullet
+
+1. New `scoreboard` phase in the engine after the stats screen, carrying every
+   player's new score, the points they just won, and the rank they held before.
+   **Feedback: the event lands in the room with both ranks.**
+2. Host screen renders the standings, animates them, and the host advances from
+   there. **Feedback: the room watches a player overtake another.**
+3. Reload lands back on the settled standings, no replay.
+
+## State machine
+
+```
+question -> [explanation] -> stats -> scoreboard -> get_ready(next)
+question -> stats -> [explanation] -> scoreboard -> get_ready(next)
+question(last) -> [explanation] -> stats -> podium
+```
+
+The standings are the last beat before the next question, whichever order the
+explanation is set to. On the last question there is nothing to stand on but the
+podium, so the scoreboard is skipped.
+
+`close_question` still settles everything at the buzzer. It now also builds the
+standings and parks them in Redis state, where every phase between the buzzer and
+the standings hands them on untouched.
+
+## Payload
+
+```json
+{
+  "type": "scoreboard",
+  "q_index": 0,
+  "total": 5,
+  "standings": [
+    {"nickname": "bob", "avatar": 4, "score": 954, "gained": 954, "rank": 1, "previous_rank": 2}
+  ],
+  "streaks": [{"nickname": "bob", "avatar": 4, "streak": 3}]
+}
+```
+
+Top five only, the same slice the stats screen used to show. Ties break on join
+time, the way the podium ranks them, so the before and after orders agree.
+
+The streak callouts move here from the stats screen: a streak is a scoreboard
+story, not an answer-split one.
+
+## Screen
+
+- Rows open in the order the room already knows (previous ranks), each showing the
+  score it had before the question.
+- After a beat the points count up on every row at once and the rows move to their
+  new places. Row identity is kept, so the move is a real move, not a repaint.
+- The rank number reads as the row's place while the list is still in its old
+  order, and switches to the true rank once the rows land. A player who dropped
+  out of the top five would otherwise leave a gap in the numbering.
+- Leader takes an accent border once settled.
+- `Next question` on the screen; auto-advance holds it for `SCOREBOARD_SECONDS`.
+
+## Reconnect
+
+`get_host_state` returns the parked standings for the `scoreboard` phase and the
+screen paints them settled: a reload mid-animation is not a reason to replay it.
+
+The player phone keeps its own result screen through the standings; it already
+shows the player's own points, rank and the top five.
+
+## Exit criteria
+
+- A room of six plays a question and sees the split, then the overtake.
+- Host reload during the standings comes back to the same standings.
+- The last question goes straight to the podium.