diff --git a/docs/analytics.md b/docs/analytics.md
index c2b71946e..66bf2099e 100644
--- a/docs/analytics.md
+++ b/docs/analytics.md
@@ -55,6 +55,7 @@ the tables here list the same events; a test
 | `account:profile_update` | | the profile form was submitted |
 | `account:fio_update` | `is_active` | the profile form was submitted |
 | `account:fio_link` | | FIO became active for a profile that had none |
+| `account:fio_link_failed` | `reason` | saving FIO credentials was refused: `fio_required`, `fio_invalid_key` or `fio_username_mismatch` |
 | `account:api_key_create` | | |
 
 ### Plan
diff --git a/docs/features/fio.md b/docs/features/fio.md
index 46411b0ef..afe3e6f61 100644
--- a/docs/features/fio.md
+++ b/docs/features/fio.md
@@ -25,8 +25,11 @@ The backend proxies the data, and the user links FIO in their profile.
 
 - FIO storage and sites live in `planningStore.fio_*` and are persisted.
   They are loaded by the `GetFIOStorage` query (`callDataFIOStorage`),
-  which `NavigationBar` triggers on app load and `PlanConstructionCart`
-  triggers when needed.
+  which `NavigationBar` triggers whenever `userStore.fioStatus` is `ok` or
+  `error` (the states that can have stored data, so also when polling turns
+  `syncing` into `ok`) and `PlanConstructionCart` triggers when needed. In
+  every other state the nav drops the query cache, but the persisted
+  `planningStore.fio_*` stays until logout.
 - The burn view calculates every plan with the planning engine
   (`calculatePlan`, game data loaded once) first, then passes the results
   into `useFIOBurn`.
diff --git a/docs/features/profile.md b/docs/features/profile.md
index b207170ba..e3bcb1cc0 100644
--- a/docs/features/profile.md
+++ b/docs/features/profile.md
@@ -9,7 +9,7 @@
 
 | Component | Does |
 | --- | --- |
-| `ChangeProfile.vue` | Edit profile fields (e.g. FIO username/key): `PatchUserProfile`, then `userStore.performGetProfile()` |
+| `ChangeProfile.vue` | Edit profile fields (e.g. FIO username/key): `PatchUserProfile`, then `userStore.performGetProfile()`. The backend checks changed FIO credentials and answers 400 with a code per field (`fio_required`, `fio_invalid_key`, `fio_username_mismatch`), shown under the field; the FIO status line reads `userStore.fioStatus` (the same state drives the nav FIO tag) |
 | `ChangePassword.vue` | `PatchUserChangePassword` |
 | `FIOInformation.vue` | Explains how to link FIO (static, i18n `profile.fio_information.*`) |
 | `UserPreferences.vue` | Edits global preferences through `usePreferences`: default empire and CX (`CXPreferenceSelector`), burn thresholds, XIT defaults, and so on |
diff --git a/src/features/api/schemas/user.schemas.ts b/src/features/api/schemas/user.schemas.ts
index 248b1cbf2..c201bd1cf 100644
--- a/src/features/api/schemas/user.schemas.ts
+++ b/src/features/api/schemas/user.schemas.ts
@@ -20,6 +20,16 @@ export const RefreshTokenResponseSchema = TokenResponseSchema.pick({
 });
 export type RefreshTokenResponse = z.infer<typeof RefreshTokenResponseSchema>;
 
+export const FIOStatusSchema = z.enum([
+	"none",
+	"syncing",
+	"ok",
+	"no_data",
+	"invalid_credentials",
+	"error",
+]);
+export type FIOStatus = z.infer<typeof FIOStatusSchema>;
+
 export const UserProfileSchema = z.object({
 	id: z.number(),
 	username: z.string(),
@@ -36,6 +46,8 @@ export const UserProfileSchema = z.object({
 		.string()
 		.transform((val) => (val === "" ? null : val))
 		.nullable(),
+	fio_status: FIOStatusSchema,
+	fio_last_refreshed_at: z.string().nullable(),
 });
 export type UserProfile = z.infer<typeof UserProfileSchema>;
 
diff --git a/src/features/profile/components/ChangeProfile.vue b/src/features/profile/components/ChangeProfile.vue
index 88f52ae55..a57c64819 100644
--- a/src/features/profile/components/ChangeProfile.vue
+++ b/src/features/profile/components/ChangeProfile.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-	import { reactive, watch, type Ref, ref, onMounted } from "vue";
+	import { computed, reactive, watch, type Ref, ref, onMounted } from "vue";
 
 	import { useI18n } from "vue-i18n";
 	const { t } = useI18n();
@@ -13,6 +13,9 @@
 	// Stores
 	import { useUserStore } from "@/stores/userStore";
 
+	// Util
+	import { relativeFromDate } from "@/util/date";
+
 	// UI
 	import {
 		PForm,
@@ -31,6 +34,36 @@
 	const wasSaved: Ref<boolean> = ref(true);
 	const codeResendRequested: Ref<boolean> = ref(false);
 
+	// backend error codes per FIO field, shown under the field
+	type FIOField = "fio_apikey" | "prun_username";
+	const KNOWN_ERRORS = [
+		"fio_required",
+		"fio_invalid_key",
+		"fio_username_mismatch",
+	];
+	const fioErrors: Ref<Partial<Record<FIOField, string>>> = ref({});
+	const fioConnected: Ref<boolean> = ref(false);
+	// until the first refresh replaces it with the real status
+	const showConnected = computed(
+		() => fioConnected.value && userStore.fioStatus === "syncing"
+	);
+
+	const fioStatusText = computed(() =>
+		t(`profile.change_profile.fio_status.${userStore.fioStatus}`, {
+			time: relativeFromDate(
+				userStore.profile?.fio_last_refreshed_at
+					? new Date(userStore.profile.fio_last_refreshed_at)
+					: undefined
+			),
+		})
+	);
+
+	function errorText(code: string): string {
+		return t(
+			`profile.change_profile.fio_errors.${KNOWN_ERRORS.includes(code) ? code : "unknown"}`
+		);
+	}
+
 	watch(
 		() => userStore.profile,
 		(newProfile) => Object.assign(localProfile, newProfile)
@@ -58,8 +91,14 @@
 		);
 
 		trackEvent("account:fio_update", { is_active: userHasFIO });
+		const fioChanged: boolean =
+			fioApiKey !== (userStore.profile?.fio_apikey ?? null) ||
+			(localProfile.prun_username ?? null) !==
+				(userStore.profile?.prun_username ?? null);
 
 		isUpdating.value = true;
+		fioErrors.value = {};
+		fioConnected.value = false;
 
 		try {
 			await useQuery("PatchUserProfile", {
@@ -69,10 +108,21 @@
 			}).execute();
 
 			if (userHasFIO && !userHadFIO) trackEvent("account:fio_link");
+			fioConnected.value = userHasFIO && fioChanged;
 
 			wasSaved.value = true;
 		} catch (err) {
 			console.error("Error patching user profile", err);
+			// DRF field errors: { field: [code] }
+			const data = (err as { responseData?: Record<string, unknown> })
+				.responseData;
+			for (const field of ["fio_apikey", "prun_username"] as const) {
+				const messages = data?.[field];
+				if (Array.isArray(messages) && typeof messages[0] === "string")
+					fioErrors.value[field] = messages[0];
+			}
+			const reason = fioErrors.value.fio_apikey ?? fioErrors.value.prun_username;
+			if (reason) trackEvent("account:fio_link_failed", { reason });
 		} finally {
 			isUpdating.value = false;
 		}
@@ -113,11 +163,39 @@
 				<PInput
 					v-model:value="localProfile.fio_apikey"
 					class="w-full min-w-50 max-w-[50%]" />
+				<template v-if="fioErrors.fio_apikey" #info>
+					<span class="text-negative" role="alert">
+						{{ errorText(fioErrors.fio_apikey) }}
+					</span>
+				</template>
 			</PFormItem>
 			<PFormItem :label="t('profile.change_profile.form.prun_username')">
 				<PInput
 					v-model:value="localProfile.prun_username"
 					class="w-full min-w-50 max-w-[50%]" />
+				<template v-if="fioErrors.prun_username" #info>
+					<span class="text-negative" role="alert">
+						{{ errorText(fioErrors.prun_username) }}
+					</span>
+				</template>
+			</PFormItem>
+			<PFormItem :label="t('profile.change_profile.form.fio_status')">
+				<div
+					class="text-sm"
+					:class="{
+						'text-positive': showConnected,
+						'text-negative':
+							!showConnected &&
+							userStore.fioStatus === 'invalid_credentials',
+					}"
+					role="status"
+					data-testid="fio-status">
+					{{
+						showConnected
+							? t("profile.change_profile.fio_connected")
+							: fioStatusText
+					}}
+				</div>
 			</PFormItem>
 			<PFormSeperator>
 				<div class="py-3 text-white/60">
diff --git a/src/layout/components/NavigationBar.vue b/src/layout/components/NavigationBar.vue
index a9e6d66b0..03abc8339 100644
--- a/src/layout/components/NavigationBar.vue
+++ b/src/layout/components/NavigationBar.vue
@@ -25,6 +25,8 @@
 
 	// Types & Interfaces
 	import type { IMenuSection } from "@/layout/components/navigation.types";
+	import type { FIOStatus } from "@/features/api/schemas/user.schemas";
+	import type { ColorKey } from "@/ui/ui.types";
 
 	// UI
 	import { PTag, PTooltip, PTable, PIcon } from "@/ui";
@@ -60,10 +62,16 @@
 	 */
 
 	watch(
-		() => userStore.hasFIO,
+		// only these states can have stored FIO data; asking in the others is a 404
+		() => userStore.hasFIO && ["ok", "error"].includes(userStore.fioStatus),
 		(newValue: boolean) => {
 			if (newValue) {
-				useQuery("GetFIOStorage").execute();
+				// still 404 for an error before any FIO data arrived
+				useQuery("GetFIOStorage")
+					.execute()
+					.catch((err: { status?: number }) => {
+						if (err.status !== 404) throw err;
+					});
 			} else {
 				queryStore.invalidateKey(["gamedata", "fio"], {
 					exact: false,
@@ -82,6 +90,21 @@
 
 	const storageAge = computed(() => planningStore.fio_storage_timestamp ?? 0);
 
+	// every state but ok links to the profile, where the status is explained
+	const FIO_TAGS: Record<
+		Exclude<FIOStatus, "ok">,
+		{ label: string; type: ColorKey }
+	> = {
+		none: { label: "fio_inactive", type: "warning" },
+		error: { label: "fio_inactive", type: "warning" },
+		syncing: { label: "fio_syncing", type: "secondary" },
+		no_data: { label: "fio_no_data", type: "warning" },
+		invalid_credentials: { label: "fio_rejected", type: "error" },
+	};
+	const fioTag = computed(() =>
+		userStore.fioStatus === "ok" ? undefined : FIO_TAGS[userStore.fioStatus]
+	);
+
 	const menuItems: ComputedRef<IMenuSection[]> = computed(() => [
 		{
 			label: t("common.navigation.planning"),
@@ -541,7 +564,7 @@
 				class="flex gap-1 justify-between items-center"
 				:class="isFull ? 'flex-row' : 'flex-col'">
 				<div>
-					<PTooltip v-if="userStore.hasFIO && storageTimestamp !== 0">
+					<PTooltip v-if="!fioTag">
 						<template #trigger>
 							<PTag size="sm" type="success" :bordered="false">
 								{{
@@ -567,10 +590,10 @@
 							<tbody>
 								<tr>
 									<td>
-										{{ relativeFromDate(storageTimestamp) }}
+										{{ relativeFromDate(storageTimestamp || undefined) }}
 									</td>
 									<td>
-										{{ relativeFromDate(storageAge) }}
+										{{ relativeFromDate(storageAge || undefined) }}
 									</td>
 								</tr>
 							</tbody>
@@ -580,10 +603,10 @@
 						v-else
 						to="/profile"
 						class="inline-flex items-center min-h-6">
-						<PTag size="sm" type="warning" :bordered="false">
+						<PTag size="sm" :type="fioTag.type" :bordered="false">
 							{{
 								isFull
-									? t("common.navigation.fio.fio_inactive")
+									? t(`common.navigation.fio.${fioTag.label}`)
 									: t("common.navigation.fio.fio")
 							}}
 						</PTag>
diff --git a/src/lib/analytics/useAnalytics.types.ts b/src/lib/analytics/useAnalytics.types.ts
index 932cd6281..719e6a3a3 100644
--- a/src/lib/analytics/useAnalytics.types.ts
+++ b/src/lib/analytics/useAnalytics.types.ts
@@ -78,6 +78,7 @@ export interface IAnalyticsEventProperties {
 	"account:profile_update": undefined;
 	"account:fio_update": { is_active: boolean };
 	"account:fio_link": undefined;
+	"account:fio_link_failed": { reason: string };
 	"account:api_key_create": undefined;
 
 	"plan:view": { planet_natural_id: string | undefined; is_shared: boolean };
diff --git a/src/locales/en_US/common.json b/src/locales/en_US/common.json
index f3a45d074..81ec6900f 100644
--- a/src/locales/en_US/common.json
+++ b/src/locales/en_US/common.json
@@ -27,7 +27,10 @@
 			"backend": "Backend",
 			"fio": "FIO",
 			"fio_active": "FIO Active",
-			"fio_inactive": "FIO Inactive"
+			"fio_inactive": "FIO Inactive",
+			"fio_syncing": "FIO Syncing",
+			"fio_no_data": "FIO Waiting for Data",
+			"fio_rejected": "FIO Key Rejected"
 		},
 		"collapse": "Collapse navigation",
 		"expand": "Expand navigation",
diff --git a/src/locales/en_US/profile.json b/src/locales/en_US/profile.json
index 4bbad17f2..331884797 100644
--- a/src/locales/en_US/profile.json
+++ b/src/locales/en_US/profile.json
@@ -26,7 +26,23 @@
 			"prun_username": "PrUn Username",
 			"email_info": "It is not required to provide an email but highly recommended for increased account safety and password recovery.",
 			"email_address": "Email Address",
-			"email_verified": "Email Verified"
+			"email_verified": "Email Verified",
+			"fio_status": "FIO Status"
+		},
+		"fio_connected": "Connected. Your data will appear in a few minutes.",
+		"fio_status": {
+			"none": "Not connected. Enter your FIO API key and PrUn username.",
+			"syncing": "Connected, loading your FIO data.",
+			"ok": "Connected. Last FIO update {time}.",
+			"no_data": "Connected, but FIO has no data for you yet. Open Prosperous Universe with the FIO extension running.",
+			"invalid_credentials": "FIO rejected your API key. Enter a valid key and save again.",
+			"error": "FIO updates are failing right now. Check your FIO key and username."
+		},
+		"fio_errors": {
+			"fio_required": "Enter both the FIO API key and the PrUn username.",
+			"fio_invalid_key": "FIO doesn't accept this API key.",
+			"fio_username_mismatch": "This API key belongs to a different PrUn username.",
+			"unknown": "Saving failed. Please try again."
 		}
 	},
 	"storage_data": {
diff --git a/src/stores/userStore.ts b/src/stores/userStore.ts
index 53e651e4f..8fe5d1d80 100644
--- a/src/stores/userStore.ts
+++ b/src/stores/userStore.ts
@@ -7,6 +7,7 @@ import {
 	reactive,
 	ref,
 	type Ref,
+	watch,
 } from "vue";
 import merge from "lodash/merge";
 
@@ -36,6 +37,7 @@ import type {
 	RefreshTokenResponse,
 	TokenResponse,
 	UserPreference,
+	FIOStatus,
 	UserProfile,
 } from "@/features/api/schemas/user.schemas";
 import { preferenceDefaults } from "@/features/preferences/userDefaults";
@@ -47,6 +49,9 @@ import {
 	type SupportedLocale,
 } from "@/lib/i18n";
 
+const FIO_POLL_MS = 15_000;
+const FIO_POLL_TRIES = 20;
+
 export const useUserStore = defineStore(
 	"prunplanner_user",
 	() => {
@@ -181,6 +186,11 @@ export const useUserStore = defineStore(
 				refreshToken.value !== undefined
 		);
 
+		// a profile persisted before fio_status existed has none until it reloads
+		const fioStatus: ComputedRef<FIOStatus> = computed(
+			() => profile.value?.fio_status ?? "none"
+		);
+
 		const hasFIO: ComputedRef<boolean> = computed(
 			() =>
 				profile.value !== undefined &&
@@ -336,6 +346,31 @@ export const useUserStore = defineStore(
 			}
 		}
 
+		/*
+		 * New FIO credentials read "syncing" until the worker's first refresh,
+		 * usually seconds: reload the profile until the status moves on, for at
+		 * most FIO_POLL_TRIES * FIO_POLL_MS
+		 */
+		let fioPoll: ReturnType<typeof setTimeout> | undefined;
+		watch(
+			fioStatus,
+			(status) => {
+				clearTimeout(fioPoll);
+				if (status !== "syncing") return;
+
+				let tries = 0;
+				const poll = () => {
+					fioPoll = setTimeout(async () => {
+						await performGetProfile();
+						if (fioStatus.value === "syncing" && ++tries < FIO_POLL_TRIES)
+							poll();
+					}, FIO_POLL_MS);
+				};
+				poll();
+			},
+			{ immediate: true }
+		);
+
 		return {
 			accessToken,
 			refreshToken,
@@ -345,6 +380,7 @@ export const useUserStore = defineStore(
 			// getters
 			isLoggedIn,
 			hasFIO,
+			fioStatus,
 			// preferences
 			intialPreferencesCalled,
 			preferences,
diff --git a/src/tests/features/api/schemas/user.schemas.test.ts b/src/tests/features/api/schemas/user.schemas.test.ts
new file mode 100644
index 000000000..6b553b079
--- /dev/null
+++ b/src/tests/features/api/schemas/user.schemas.test.ts
@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+
+import { UserProfileSchema } from "@/features/api/schemas/user.schemas";
+
+const base = {
+	id: 1,
+	username: "test",
+	email: null,
+	is_email_verified: true,
+	fio_apikey: "key",
+	prun_username: "PRUN",
+};
+
+describe("UserProfileSchema", () => {
+	it("takes the FIO status and the last refresh", () => {
+		const parsed = UserProfileSchema.parse({
+			...base,
+			fio_status: "no_data",
+			fio_last_refreshed_at: "2026-10-01T12:00:00Z",
+		});
+
+		expect(parsed.fio_status).toBe("no_data");
+		expect(parsed.fio_last_refreshed_at).toBe("2026-10-01T12:00:00Z");
+	});
+
+	it("allows no refresh yet", () => {
+		expect(
+			UserProfileSchema.parse({
+				...base,
+				fio_status: "syncing",
+				fio_last_refreshed_at: null,
+			}).fio_last_refreshed_at
+		).toBeNull();
+	});
+
+	it("rejects an unknown status", () => {
+		expect(
+			UserProfileSchema.safeParse({
+				...base,
+				fio_status: "broken",
+				fio_last_refreshed_at: null,
+			}).success
+		).toBe(false);
+	});
+});
diff --git a/src/tests/features/api/userData.api.test.ts b/src/tests/features/api/userData.api.test.ts
index e3f864870..cad51abdf 100644
--- a/src/tests/features/api/userData.api.test.ts
+++ b/src/tests/features/api/userData.api.test.ts
@@ -80,6 +80,8 @@ describe("Feature: Account", () => {
 			is_email_verified: true,
 			fio_apikey: "foo@moo.de",
 			prun_username: "foo",
+			fio_status: "ok",
+			fio_last_refreshed_at: "2026-10-01T12:00:00Z",
 		};
 
 		// @ts-expect-error - mock post typing
@@ -100,6 +102,8 @@ describe("Feature: Account", () => {
 			email: "",
 			fio_apikey: "foo@moo.de",
 			prun_username: "foo",
+			fio_status: "ok",
+			fio_last_refreshed_at: "2026-10-01T12:00:00Z",
 		};
 
 		// @ts-expect-error - mock post typing
diff --git a/src/tests/features/profile/components/ChangeProfile.test.ts b/src/tests/features/profile/components/ChangeProfile.test.ts
index 43cc1b7c8..81e8969e4 100644
--- a/src/tests/features/profile/components/ChangeProfile.test.ts
+++ b/src/tests/features/profile/components/ChangeProfile.test.ts
@@ -48,6 +48,8 @@ function profile(patch: Partial<UserProfile> = {}): UserProfile {
 		is_email_verified: true,
 		fio_apikey: "test-fio-key",
 		prun_username: "test-prun-user",
+		fio_status: "ok",
+		fio_last_refreshed_at: null,
 		...patch,
 	};
 }
@@ -431,4 +433,125 @@ describe("ChangeProfile", () => {
 		expect(wrapper.text()).toContain(RESEND);
 		expect(wrapper.text()).not.toContain(REQUESTED);
 	});
+
+	describe("FIO credential check", () => {
+		const ERRORS = "profile.change_profile.fio_errors";
+		const noFIO = profile({
+			fio_apikey: null,
+			prun_username: null,
+			fio_status: "none",
+		});
+
+		async function link(patchStatus: number, body: object) {
+			mock.resetHandlers();
+			mock.onGet(PROFILE_URL).reply(200, noFIO);
+			mock.onPatch(PROFILE_URL).reply(patchStatus, body);
+			vi.spyOn(console, "error").mockImplementation(() => {});
+			const { wrapper } = await mountProfile(noFIO);
+			await inputs(wrapper).at(0)!.setValue("key");
+			await inputs(wrapper).at(1)!.setValue("PRUN");
+			await save(wrapper);
+			return wrapper;
+		}
+
+		it.each([
+			["fio_apikey", "fio_invalid_key"],
+			["prun_username", "fio_username_mismatch"],
+			["fio_apikey", "fio_required"],
+		])("shows %s: %s under its field", async (field, code) => {
+			const wrapper = await link(400, { [field]: [code] });
+
+			const alerts = wrapper.findAll("[role=alert]");
+			expect(alerts.map((a) => a.text())).toEqual([`${ERRORS}.${code}`]);
+			// the error sits in the field's own form item
+			const label =
+				field === "fio_apikey"
+					? "profile.change_profile.form.fio_apikey"
+					: "profile.change_profile.form.prun_username";
+			const labelId = wrapper
+				.findAll("label")
+				.find((l) => l.text() === label)!
+				.attributes("id");
+			expect(
+				alerts[0].element.closest("div")!.previousElementSibling!
+					.previousElementSibling!.id
+			).toBe(labelId);
+			expect(saveType(wrapper)).toBe("error");
+			expect(trackEvent).toHaveBeenCalledWith("account:fio_link_failed", {
+				reason: code,
+			});
+			expect(trackEvent).not.toHaveBeenCalledWith("account:fio_link");
+		});
+
+		it("falls back to a generic message for an unknown code", async () => {
+			const wrapper = await link(400, { prun_username: ["other"] });
+
+			expect(wrapper.find("[role=alert]").text()).toBe(`${ERRORS}.unknown`);
+		});
+
+		it("shows no FIO error for other failures", async () => {
+			const wrapper = await link(500, {});
+
+			expect(wrapper.findAll("[role=alert]")).toHaveLength(0);
+			expect(trackEvent).not.toHaveBeenCalledWith(
+				"account:fio_link_failed",
+				expect.anything()
+			);
+		});
+
+		it("confirms the connection and clears old errors on success", async () => {
+			const wrapper = await link(400, { fio_apikey: ["fio_invalid_key"] });
+			mock.resetHandlers();
+			mock.onPatch(PROFILE_URL).reply(
+				200,
+				profile({ prun_username: "PRUN", fio_apikey: "key" })
+			);
+			mock.onGet(PROFILE_URL).reply(
+				200,
+				profile({
+					prun_username: "PRUN",
+					fio_apikey: "key",
+					fio_status: "syncing",
+				})
+			);
+
+			await save(wrapper);
+
+			expect(wrapper.findAll("[role=alert]")).toHaveLength(0);
+			expect(wrapper.find("[data-testid=fio-status]").text()).toBe(
+				"profile.change_profile.fio_connected"
+			);
+			expect(trackEvent).toHaveBeenCalledWith("account:fio_link");
+
+			// the first refresh replaces it with the real status
+			useUserStore().profile = profile({
+				prun_username: "PRUN",
+				fio_apikey: "key",
+				fio_status: "ok",
+			});
+			await flushPromises();
+			expect(wrapper.find("[data-testid=fio-status]").text()).toBe(
+				"profile.change_profile.fio_status.ok"
+			);
+		});
+
+		it.each([
+			"none",
+			"syncing",
+			"ok",
+			"no_data",
+			"invalid_credentials",
+			"error",
+		] as const)("shows the %s status", async (status) => {
+			mock.resetHandlers();
+			mock.onGet(PROFILE_URL).reply(200, profile({ fio_status: status }));
+			const { wrapper } = await mountProfile(
+				profile({ fio_status: status })
+			);
+
+			expect(wrapper.find("[data-testid=fio-status]").text()).toBe(
+				`profile.change_profile.fio_status.${status}`
+			);
+		});
+	});
 });
diff --git a/src/tests/layout/components/NavigationBar.test.ts b/src/tests/layout/components/NavigationBar.test.ts
new file mode 100644
index 000000000..c64f04238
--- /dev/null
+++ b/src/tests/layout/components/NavigationBar.test.ts
@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { flushPromises, RouterLinkStub } from "@vue/test-utils";
+import { createPinia, type Pinia, setActivePinia } from "pinia";
+
+import { useUserStore } from "@/stores/userStore";
+import NavigationBar from "@/layout/components/NavigationBar.vue";
+import PTag from "@/ui/components/PTag.vue";
+import { mountComponent } from "@/tests/mountComponent";
+
+// Types & Interfaces
+import type {
+	FIOStatus,
+	UserProfile,
+} from "@/features/api/schemas/user.schemas";
+
+vi.mock("@/router", () => ({ default: { push: vi.fn() } }));
+const execute = vi.fn();
+vi.mock("@/lib/query_cache/useQuery", () => ({
+	useQuery: () => ({ execute }),
+}));
+
+const FIO = "common.navigation.fio";
+
+function profile(fio_status: FIOStatus): UserProfile {
+	return {
+		id: 1,
+		username: "test-user",
+		email: null,
+		is_email_verified: true,
+		fio_apikey: fio_status === "none" ? null : "key",
+		prun_username: fio_status === "none" ? null : "PRUN",
+		fio_status,
+		fio_last_refreshed_at: null,
+	};
+}
+
+let pinia: Pinia;
+
+async function fioTag(status: FIOStatus) {
+	useUserStore().profile = profile(status);
+	const { wrapper } = await mountComponent(NavigationBar, {}, { pinia });
+	const tag = wrapper.findAllComponents(PTag).at(-1)!;
+	const link = wrapper
+		.findAllComponents(RouterLinkStub)
+		.find((l) => l.findComponent(PTag).exists());
+	return { text: tag.text(), type: tag.props("type"), link: link?.props("to") };
+}
+
+describe("NavigationBar FIO tag", () => {
+	beforeEach(() => {
+		pinia = createPinia();
+		setActivePinia(pinia);
+		execute.mockReset().mockResolvedValue(undefined);
+	});
+
+	it("handles the storage 404 of a failing user without FIO data", async () => {
+		const notFound = Promise.reject(
+			Object.assign(new Error("No storage data available."), {
+				status: 404,
+			})
+		);
+		const handled = vi.spyOn(notFound, "catch");
+		execute.mockReturnValue(notFound);
+
+		expect((await fioTag("error")).text).toBe(`${FIO}.fio_inactive`);
+		expect(execute).toHaveBeenCalledOnce();
+		// an unhandled rejection doesn't fail this run, so check it is caught
+		expect(handled).toHaveBeenCalledOnce();
+	});
+
+	it.each([
+		["none", `${FIO}.fio_inactive`, "warning"],
+		["error", `${FIO}.fio_inactive`, "warning"],
+		["syncing", `${FIO}.fio_syncing`, "secondary"],
+		["no_data", `${FIO}.fio_no_data`, "warning"],
+		["invalid_credentials", `${FIO}.fio_rejected`, "error"],
+	] as const)("%s links to the profile", async (status, text, type) => {
+		expect(await fioTag(status)).toEqual({ text, type, link: "/profile" });
+	});
+
+	it.each(["syncing", "no_data", "invalid_credentials"] as const)(
+		"does not ask for storage while %s",
+		async (status) => {
+			await fioTag(status);
+			expect(execute).not.toHaveBeenCalled();
+		}
+	);
+
+	it("loads the storage once the first refresh is done", async () => {
+		await fioTag("syncing");
+
+		useUserStore().profile = profile("ok");
+		await flushPromises();
+
+		expect(execute).toHaveBeenCalledOnce();
+	});
+
+	it("ok shows FIO as active, without a link", async () => {
+		expect(await fioTag("ok")).toEqual({
+			text: `${FIO}.fio_active`,
+			type: "success",
+			link: undefined,
+		});
+	});
+});
diff --git a/src/tests/stores/userStore.test.ts b/src/tests/stores/userStore.test.ts
index ec56a51ce..21fe3f892 100644
--- a/src/tests/stores/userStore.test.ts
+++ b/src/tests/stores/userStore.test.ts
@@ -1,4 +1,4 @@
-import { createApp } from "vue";
+import { createApp, nextTick } from "vue";
 import { setActivePinia, createPinia } from "pinia";
 import piniaPluginPersistedstate from "pinia-plugin-persistedstate";
 import {
@@ -203,6 +203,112 @@ describe("User Store", () => {
 		expect(result).toBe(false);
 	});
 
+	describe("fioStatus", () => {
+		it("is none without a profile", () => {
+			expect(useUserStore().fioStatus).toBe("none");
+		});
+
+		it("follows the profile", () => {
+			const userStore = useUserStore();
+			userStore.profile = {
+				id: 1,
+				username: "test",
+				email: null,
+				is_email_verified: false,
+				fio_apikey: "foo",
+				prun_username: "moo",
+				fio_status: "invalid_credentials",
+				fio_last_refreshed_at: null,
+			};
+
+			expect(userStore.fioStatus).toBe("invalid_credentials");
+		});
+
+		describe("polling while syncing", () => {
+			const withStatus = (
+				fio_status: UserProfile["fio_status"]
+			): UserProfile => ({
+				id: 1,
+				username: "test",
+				email: null,
+				is_email_verified: false,
+				fio_apikey: "foo",
+				prun_username: "moo",
+				fio_status,
+				fio_last_refreshed_at: null,
+			});
+			const getProfile = callGetProfile as unknown as ReturnType<
+				typeof vi.fn
+			>;
+
+			beforeEach(() => {
+				vi.useFakeTimers();
+				getProfile.mockReset();
+				onTestFinished(() => {
+					vi.useRealTimers();
+				});
+			});
+
+			it("reloads the profile until the status moves on", async () => {
+				const userStore = useUserStore();
+				userStore.accessToken = "foo";
+				userStore.refreshToken = "moo";
+				getProfile
+					.mockResolvedValueOnce(withStatus("syncing"))
+					.mockResolvedValueOnce(withStatus("ok"));
+
+				userStore.profile = withStatus("syncing");
+				await nextTick();
+				await vi.advanceTimersByTimeAsync(15_000);
+				expect(getProfile).toHaveBeenCalledTimes(1);
+
+				await vi.advanceTimersByTimeAsync(15_000);
+				expect(userStore.fioStatus).toBe("ok");
+
+				await vi.advanceTimersByTimeAsync(60_000);
+				expect(getProfile).toHaveBeenCalledTimes(2);
+			});
+
+			it("gives up after 20 tries", async () => {
+				const userStore = useUserStore();
+				userStore.accessToken = "foo";
+				userStore.refreshToken = "moo";
+				getProfile.mockResolvedValue(withStatus("syncing"));
+
+				userStore.profile = withStatus("syncing");
+				await nextTick();
+				await vi.advanceTimersByTimeAsync(30 * 15_000);
+
+				expect(getProfile).toHaveBeenCalledTimes(20);
+			});
+
+			it("stops on logout", async () => {
+				const userStore = useUserStore();
+				userStore.accessToken = "foo";
+				userStore.refreshToken = "moo";
+				userStore.profile = withStatus("syncing");
+				// the poll is running
+				await nextTick();
+
+				userStore.$reset();
+				await vi.advanceTimersByTimeAsync(60_000);
+
+				expect(getProfile).not.toHaveBeenCalled();
+			});
+
+			it("does not poll other states", async () => {
+				const userStore = useUserStore();
+				userStore.accessToken = "foo";
+				userStore.refreshToken = "moo";
+
+				userStore.profile = withStatus("no_data");
+				await vi.advanceTimersByTimeAsync(60_000);
+
+				expect(getProfile).not.toHaveBeenCalled();
+			});
+		});
+	});
+
 	describe("hasFIO", async () => {
 		const hasFIOCases = [
 			{
@@ -292,6 +398,8 @@ describe("User Store", () => {
 				is_email_verified: true,
 				fio_apikey: "foo",
 				prun_username: "moo",
+				fio_status: "ok",
+				fio_last_refreshed_at: null,
 			};
 
 			const userStore = useUserStore();