diff --git a/apps/desktop/src/components/network-health-indicator.tsx b/apps/desktop/src/components/network-health-indicator.tsx
new file mode 100644
index 00000000000..b0450f2a4ba
--- /dev/null
+++ b/apps/desktop/src/components/network-health-indicator.tsx
@@ -0,0 +1,146 @@
+import { cx } from "cva";
+import { Show } from "solid-js";
+import Tooltip from "~/components/Tooltip";
+import {
+	isRecordingInProgress,
+	networkHealth,
+	runSpeedTest,
+	runUploadHealthCheck,
+	speedTest,
+} from "~/utils/network-health";
+import IconLucideAlertTriangle from "~icons/lucide/alert-triangle";
+import IconLucideRefreshCw from "~icons/lucide/refresh-cw";
+import IconLucideWifi from "~icons/lucide/wifi";
+
+interface NetworkHealthIndicatorProps {
+	class?: string;
+}
+
+export default function NetworkHealthIndicator(
+	props: NetworkHealthIndicatorProps,
+) {
+	const isUnhealthy = () => networkHealth().status === "unhealthy";
+	const isChecking = () =>
+		networkHealth().status === "checking" || speedTest().status === "running";
+	const isRecording = isRecordingInProgress;
+
+	const handleRefresh = async (e: MouseEvent) => {
+		e.stopPropagation();
+		if (isRecording() || isChecking()) return;
+		await runUploadHealthCheck();
+		await runSpeedTest();
+	};
+
+	const speedLabel = () => {
+		if (speedTest().status === "running") return "Testing...";
+		if (speedTest().status === "error" && speedTest().speedMbps === null)
+			return "Failed";
+		if (speedTest().speedMbps !== null) return `${speedTest().speedMbps} Mbps`;
+		if (networkHealth().status === "checking") return "Checking...";
+		if (isUnhealthy()) return "Offline";
+		return "Ready";
+	};
+
+	const qualityLabel = () => {
+		const label = speedTest().recommendedLabel;
+		return label ? `${label}` : "1080p";
+	};
+
+	const dotColor = () => {
+		if (isUnhealthy()) return "bg-red-9";
+		if (speedTest().status === "running") return "bg-blue-9 animate-pulse";
+		if (speedTest().status === "error" && speedTest().speedMbps === null)
+			return "bg-red-9";
+		const speed = speedTest().speedMbps;
+		if (speed === null) return "bg-gray-8";
+		if (speed >= 15) return "bg-green-9";
+		if (speed >= 5) return "bg-blue-9";
+		return "bg-amber-9";
+	};
+
+	const tooltipContent = () => (
+		<div class="flex flex-col gap-1 p-1 text-left text-xs min-w-44">
+			<div class="flex items-center justify-between font-semibold">
+				<span>Network Health</span>
+				<span
+					class={cx(
+						"text-[10px] uppercase font-bold",
+						isUnhealthy() || speedTest().status === "error"
+							? "text-red-10"
+							: "text-green-10",
+					)}
+				>
+					{isUnhealthy() ||
+					(speedTest().status === "error" && speedTest().speedMbps === null)
+						? "Error"
+						: "Operational"}
+				</span>
+			</div>
+			<div class="flex items-center justify-between text-gray-11">
+				<span>Upload Speed:</span>
+				<span class="font-medium text-gray-12">{speedLabel()}</span>
+			</div>
+			<div class="flex items-center justify-between text-gray-11">
+				<span>Recommended Quality:</span>
+				<span class="font-medium text-gray-12">{qualityLabel()}</span>
+			</div>
+			<Show when={networkHealth().error || speedTest().error}>
+				<div class="mt-1 rounded bg-red-3 p-1.5 text-[11px] text-red-11 border border-red-6">
+					{networkHealth().error ?? speedTest().error}
+				</div>
+			</Show>
+			<div class="mt-1 pt-1 border-t border-gray-6 flex justify-end">
+				<button
+					type="button"
+					onClick={handleRefresh}
+					disabled={isRecording() || isChecking()}
+					class="flex items-center gap-1 text-[11px] text-gray-11 hover:text-gray-12 disabled:opacity-50"
+				>
+					<IconLucideRefreshCw
+						class={cx("size-3", isChecking() && "animate-spin")}
+					/>
+					<span>Retest Speed</span>
+				</button>
+			</div>
+		</div>
+	);
+
+	return (
+		<div
+			class={cx("inline-flex items-center gap-1.5 select-none", props.class)}
+		>
+			<Tooltip content={tooltipContent()}>
+				<button
+					type="button"
+					onClick={handleRefresh}
+					disabled={isRecording()}
+					aria-label="Network health and speed indicator"
+					class={cx(
+						"flex items-center gap-1.5 px-2 py-0.5 rounded-full text-[11px] transition-colors border",
+						isUnhealthy() ||
+							(speedTest().status === "error" && speedTest().speedMbps === null)
+							? "bg-red-3 text-red-11 border-red-6 hover:bg-red-4"
+							: "bg-gray-2 text-gray-11 border-gray-6 hover:bg-gray-3 hover:text-gray-12",
+					)}
+				>
+					<Show
+						when={
+							!isUnhealthy() &&
+							!(
+								speedTest().status === "error" && speedTest().speedMbps === null
+							)
+						}
+						fallback={<IconLucideAlertTriangle class="size-3 text-red-9" />}
+					>
+						<span class={cx("size-1.5 rounded-full shrink-0", dotColor())} />
+						<IconLucideWifi class="size-3 shrink-0" />
+					</Show>
+					<span class="font-medium truncate max-w-20">
+						{isUnhealthy() ? "Upload Error" : speedLabel()}
+					</span>
+				</button>
+			</Tooltip>
+		</div>
+	);
+}
+export { NetworkHealthIndicator };
diff --git a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
index b0981c60573..a72db044b92 100644
--- a/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
+++ b/apps/desktop/src/routes/(window-chrome)/new-main/index.tsx
@@ -37,6 +37,7 @@ import { createStore, produce, reconcile } from "solid-js/store";
 import toast from "solid-toast";
 import { Transition } from "solid-transition-group";
 import Mode from "~/components/Mode";
+import NetworkHealthIndicator from "~/components/network-health-indicator";
 import { RecoveryToast } from "~/components/RecoveryToast";
 import Tooltip from "~/components/Tooltip";
 import { Input } from "~/routes/editor/ui";
@@ -59,6 +60,10 @@ import {
 	importVideoFromPicker,
 	showImportError,
 } from "~/utils/importMedia";
+import {
+	initNetworkHealthMonitoring,
+	setRecordingState,
+} from "~/utils/network-health";
 import {
 	createCameraMutation,
 	createCleanCaptureQuery,
@@ -1846,6 +1851,16 @@ function Page() {
 	const isRecording = () => !!currentRecording.data;
 	const isActivelyRecording = () =>
 		currentRecording.data?.status === "recording";
+
+	createEffect(() => {
+		setRecordingState(isRecording());
+	});
+
+	onMount(() => {
+		const cleanup = initNetworkHealthMonitoring();
+		onCleanup(cleanup);
+	});
+
 	const auth = authStore.createQuery();
 	const recordingSettingsQuery = recordingDeviceSettingsStore.createQuery();
 	const generalSettings = generalSettingsStore.createQuery();
@@ -2984,6 +2999,9 @@ function Page() {
 					</div>
 				</div>
 				<BaseControls />
+				<div class="flex items-center justify-end pt-1 px-0.5 text-xs text-gray-11">
+					<NetworkHealthIndicator />
+				</div>
 			</div>
 		</Transition>
 	);
@@ -3153,6 +3171,7 @@ function Page() {
 											? new URL("/dashboard", serverUrl()).toString()
 											: serverUrl()
 									}
+									rel="noopener"
 								>
 									<IconCapLogoFullDark class="hidden dark:block" />
 									<IconCapLogoFull class="block dark:hidden" />
diff --git a/apps/desktop/src/utils/network-health.test.ts b/apps/desktop/src/utils/network-health.test.ts
new file mode 100644
index 00000000000..90efcc065f0
--- /dev/null
+++ b/apps/desktop/src/utils/network-health.test.ts
@@ -0,0 +1,257 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	calculateSpeedMbps,
+	determineQualityTierAndResolution,
+	formatResolutionLabel,
+	initNetworkHealthMonitoring,
+	isRecordingInProgress,
+	networkHealth,
+	runSpeedTest,
+	runUploadHealthCheck,
+	setRecordingState,
+	speedTest,
+} from "./network-health";
+
+describe("network-health speed test & quality adaptation", () => {
+	it("correctly maps speeds to adaptive quality tiers and resolution labels", () => {
+		const ultraTier = determineQualityTierAndResolution(30);
+		expect(ultraTier.qualityTier).toBe("high");
+		expect(ultraTier.recommendedResolution).toBe(3840);
+		expect(ultraTier.recommendedLabel).toBe("4K");
+
+		const highTier = determineQualityTierAndResolution(18);
+		expect(highTier.qualityTier).toBe("high");
+		expect(highTier.recommendedResolution).toBe(1920);
+		expect(highTier.recommendedLabel).toBe("1080p");
+
+		const mediumTier = determineQualityTierAndResolution(8);
+		expect(mediumTier.qualityTier).toBe("medium");
+		expect(mediumTier.recommendedResolution).toBe(1280);
+		expect(mediumTier.recommendedLabel).toBe("720p");
+
+		const lowTier = determineQualityTierAndResolution(1.5);
+		expect(lowTier.qualityTier).toBe("low");
+		expect(lowTier.recommendedResolution).toBe(960);
+		expect(lowTier.recommendedLabel).toBe("540p");
+
+		expect(formatResolutionLabel(3840)).toBe("4K");
+		expect(formatResolutionLabel(1920)).toBe("1080p");
+		expect(formatResolutionLabel(1280)).toBe("720p");
+		expect(formatResolutionLabel(960)).toBe("540p");
+	});
+
+	it("calculates upload speed in Mbps accurately", () => {
+		const oneMegabyte = 1024 * 1024;
+		const durationMs = 1000;
+		const speed = calculateSpeedMbps(oneMegabyte, durationMs);
+		expect(speed).toBeCloseTo(8.4, 0);
+
+		expect(calculateSpeedMbps(0, 1000)).toBe(0);
+		expect(calculateSpeedMbps(1024, 0)).toBe(0);
+	});
+
+	it("does not perform speed checks once recording has already started", async () => {
+		setRecordingState(true);
+		expect(isRecordingInProgress()).toBe(true);
+
+		const result = await runSpeedTest();
+		expect(result).toBe(speedTest().speedMbps);
+
+		setRecordingState(false);
+		expect(isRecordingInProgress()).toBe(false);
+	});
+
+	it("manages health check state transitions and clears errors upon recovery", async () => {
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({ status: "ok" }),
+		} as Response);
+
+		const success = await runUploadHealthCheck();
+		expect(success).toBe(true);
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		globalThis.fetch = vi
+			.fn()
+			.mockRejectedValue(new Error("Connection refused"));
+		const failure = await runUploadHealthCheck();
+		expect(failure).toBe(false);
+		expect(networkHealth().status).toBe("unhealthy");
+		expect(networkHealth().error).toContain("Connection refused");
+
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: true,
+			json: async () => ({ status: "ok" }),
+		} as Response);
+		const recovery = await runUploadHealthCheck();
+		expect(recovery).toBe(true);
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		globalThis.fetch = originalFetch;
+	});
+
+	it("handles rate limiting and server errors gracefully during speed tests", async () => {
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = vi.fn().mockResolvedValue({
+			ok: false,
+			status: 429,
+			statusText: "Too Many Requests",
+		} as Response);
+
+		const result = await runSpeedTest();
+		expect(result).toBeNull();
+		expect(speedTest().status).toBe("error");
+		expect(speedTest().error).toContain("429");
+
+		globalThis.fetch = originalFetch;
+	});
+
+	it("clears unhealthy network health status upon successful speed test completion", async () => {
+		const originalFetch = globalThis.fetch;
+
+		globalThis.fetch = vi
+			.fn()
+			.mockRejectedValue(new Error("Offline: network unreachable"));
+		await runUploadHealthCheck();
+		expect(networkHealth().status).toBe("unhealthy");
+		expect(networkHealth().error).toContain("Offline: network unreachable");
+
+		const mockFetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const body =
+					typeof init?.body === "string" ? JSON.parse(init.body) : {};
+				if (body.payload === "ping") {
+					return Promise.resolve({
+						ok: true,
+						json: async () => ({
+							success: true,
+							bytesReceived: 4,
+							timestamp: Date.now(),
+						}),
+					} as Response);
+				}
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+		globalThis.fetch = mockFetch;
+
+		const speed = await runSpeedTest();
+		expect(speed).toBeGreaterThan(0);
+		expect(speedTest().status).toBe("completed");
+		expect(speedTest().error).toBeNull();
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+		expect(mockFetch).toHaveBeenCalledTimes(4);
+
+		globalThis.fetch = originalFetch;
+	});
+
+	it("prevents delayed health check failure from overwriting newer successful status", async () => {
+		const originalFetch = globalThis.fetch;
+
+		let delayedReject!: (err: Error) => void;
+		let getEnteredMock = false;
+		const delayedPromise = new Promise<Response>((_, reject) => {
+			delayedReject = reject;
+		});
+		delayedPromise.catch(() => {});
+
+		globalThis.fetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const method = init?.method ?? "GET";
+				if (method === "GET") {
+					getEnteredMock = true;
+					return delayedPromise;
+				}
+
+				const body =
+					typeof init?.body === "string" ? JSON.parse(init.body) : {};
+				if (body.payload === "ping") {
+					return Promise.resolve({
+						ok: true,
+						json: async () => ({
+							success: true,
+							bytesReceived: 4,
+							timestamp: Date.now(),
+						}),
+					} as Response);
+				}
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+
+		const pendingCheck = runUploadHealthCheck();
+		await new Promise((resolve) => setTimeout(resolve, 15));
+		expect(getEnteredMock).toBe(true);
+
+		await runSpeedTest();
+		expect(networkHealth().status).toBe("healthy");
+
+		delayedReject(new Error("Late network timeout"));
+		const checkResult = await pendingCheck;
+		expect(checkResult).toBe(false);
+
+		expect(networkHealth().status).toBe("healthy");
+		expect(networkHealth().error).toBeNull();
+
+		globalThis.fetch = originalFetch;
+	});
+
+	it("stops scheduled speed tests after monitoring is disposed", async () => {
+		const originalFetch = globalThis.fetch;
+		let postCallCount = 0;
+
+		let resolveHealth!: (res: Response) => void;
+		const healthPromise = new Promise<Response>((resolve) => {
+			resolveHealth = resolve;
+		});
+
+		globalThis.fetch = vi
+			.fn()
+			.mockImplementation((_url: string, init?: RequestInit) => {
+				const method = init?.method ?? "GET";
+				if (method === "GET") {
+					return healthPromise;
+				}
+				postCallCount++;
+				return Promise.resolve({
+					ok: true,
+					json: async () => ({
+						success: true,
+						bytesReceived: 512 * 1024,
+						timestamp: Date.now(),
+					}),
+				} as Response);
+			});
+
+		const stopMonitoring = initNetworkHealthMonitoring();
+		stopMonitoring();
+
+		resolveHealth({
+			ok: true,
+			json: async () => ({ status: "ok" }),
+		} as Response);
+		await new Promise((resolve) => setTimeout(resolve, 30));
+
+		expect(postCallCount).toBe(0);
+
+		globalThis.fetch = originalFetch;
+	});
+});
diff --git a/apps/desktop/src/utils/network-health.ts b/apps/desktop/src/utils/network-health.ts
new file mode 100644
index 00000000000..6badd7b7e28
--- /dev/null
+++ b/apps/desktop/src/utils/network-health.ts
@@ -0,0 +1,371 @@
+import { fetch as tauriFetch } from "@tauri-apps/plugin-http";
+import { createSignal } from "solid-js";
+
+export type QualityTier = "high" | "medium" | "low";
+
+export interface NetworkHealthState {
+	status: "idle" | "checking" | "healthy" | "unhealthy";
+	lastChecked: number | null;
+	error: string | null;
+}
+
+export interface SpeedTestState {
+	status: "idle" | "running" | "completed" | "error";
+	speedMbps: number | null;
+	qualityTier: QualityTier | null;
+	recommendedResolution: number;
+	recommendedLabel: string;
+	lastTested: number | null;
+	error: string | null;
+}
+
+export const SPEED_THRESHOLDS = {
+	highSpeedMinMbps: 15,
+	mediumSpeedMinMbps: 5,
+	lowSpeedMinMbps: 2,
+} as const;
+
+export const RESOLUTION_PRESETS = {
+	ultra: 3840,
+	high: 1920,
+	medium: 1280,
+	low: 960,
+} as const;
+
+export function formatResolutionLabel(width: number): string {
+	if (width >= 3840) return "4K";
+	if (width >= 2560) return "1440p";
+	if (width >= 1920) return "1080p";
+	if (width >= 1280) return "720p";
+	return "540p";
+}
+
+function getHttpFetch(): typeof globalThis.fetch {
+	if (typeof window !== "undefined") {
+		return tauriFetch;
+	}
+	return globalThis.fetch;
+}
+
+async function getServerUrl(): Promise<string> {
+	try {
+		const { getConfiguredServerUrl } = await import("./web-api");
+		return await getConfiguredServerUrl();
+	} catch {
+		return "http://localhost:3000";
+	}
+}
+
+const [networkHealth, setNetworkHealth] = createSignal<NetworkHealthState>({
+	status: "idle",
+	lastChecked: null,
+	error: null,
+});
+
+const [speedTest, setSpeedTest] = createSignal<SpeedTestState>({
+	status: "idle",
+	speedMbps: null,
+	qualityTier: null,
+	recommendedResolution: RESOLUTION_PRESETS.high,
+	recommendedLabel: "1080p",
+	lastTested: null,
+	error: null,
+});
+
+const [isRecordingSignal, setIsRecordingSignal] = createSignal(false);
+let activeSpeedTestAbort: AbortController | null = null;
+
+export function setRecordingState(active: boolean) {
+	setIsRecordingSignal(active);
+	if (active && activeSpeedTestAbort) {
+		activeSpeedTestAbort.abort();
+		activeSpeedTestAbort = null;
+		setSpeedTest((prev) => ({
+			...prev,
+			status: prev.speedMbps !== null ? "completed" : "idle",
+		}));
+	}
+}
+
+export function isRecordingInProgress(): boolean {
+	return isRecordingSignal();
+}
+
+export function determineQualityTierAndResolution(speedMbps: number): {
+	qualityTier: QualityTier;
+	recommendedResolution: number;
+	recommendedLabel: string;
+} {
+	if (speedMbps >= 25) {
+		return {
+			qualityTier: "high",
+			recommendedResolution: RESOLUTION_PRESETS.ultra,
+			recommendedLabel: "4K",
+		};
+	}
+	if (speedMbps >= SPEED_THRESHOLDS.highSpeedMinMbps) {
+		return {
+			qualityTier: "high",
+			recommendedResolution: RESOLUTION_PRESETS.high,
+			recommendedLabel: "1080p",
+		};
+	}
+	if (speedMbps >= SPEED_THRESHOLDS.mediumSpeedMinMbps) {
+		return {
+			qualityTier: "medium",
+			recommendedResolution: RESOLUTION_PRESETS.medium,
+			recommendedLabel: "720p",
+		};
+	}
+	return {
+		qualityTier: "low",
+		recommendedResolution: RESOLUTION_PRESETS.low,
+		recommendedLabel: "540p",
+	};
+}
+
+export function calculateSpeedMbps(bytes: number, durationMs: number): number {
+	if (durationMs <= 0 || bytes <= 0) return 0;
+	const durationSeconds = durationMs / 1000;
+	const bits = bytes * 8;
+	const mbps = bits / (durationSeconds * 1_000_000);
+	return Math.round(mbps * 10) / 10;
+}
+
+export async function runUploadHealthCheck(): Promise<boolean> {
+	const startedAt = Date.now();
+	setNetworkHealth((prev) => ({
+		...prev,
+		status: "checking",
+		error: null,
+	}));
+
+	try {
+		const baseUrl = await getServerUrl();
+		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 8000);
+
+		const fetchFn = getHttpFetch();
+		const response = await fetchFn(targetUrl, {
+			method: "GET",
+			signal: controller.signal,
+		});
+
+		clearTimeout(timeoutId);
+
+		if (!response.ok) {
+			throw new Error(`Health check returned HTTP ${response.status}`);
+		}
+
+		const data = (await response.json()) as {
+			status?: string;
+		};
+		const isHealthy = data.status === "ok";
+
+		if (!isHealthy) {
+			throw new Error("Server responded with unhealthy status");
+		}
+
+		setNetworkHealth({
+			status: "healthy",
+			lastChecked: Date.now(),
+			error: null,
+		});
+		return true;
+	} catch (error) {
+		const errorMessage =
+			error instanceof Error ? error.message : "Upload health check failed";
+		const current = networkHealth();
+		if (current.lastChecked === null || current.lastChecked <= startedAt) {
+			setNetworkHealth({
+				status: "unhealthy",
+				lastChecked: Date.now(),
+				error: errorMessage,
+			});
+		}
+		return false;
+	}
+}
+
+export async function runSpeedTest(): Promise<number | null> {
+	if (isRecordingSignal()) {
+		return speedTest().speedMbps;
+	}
+
+	activeSpeedTestAbort?.abort();
+	const controller = new AbortController();
+	activeSpeedTestAbort = controller;
+
+	setSpeedTest((prev) => ({
+		...prev,
+		status: "running",
+		error: null,
+	}));
+
+	try {
+		const baseUrl = await getServerUrl();
+		const targetUrl = new URL("/api/desktop/health", baseUrl).toString();
+		const fetchFn = getHttpFetch();
+
+		const warmupResponse = await fetchFn(targetUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ payload: "ping" }),
+			signal: controller.signal,
+		});
+
+		if (!warmupResponse.ok) {
+			throw new Error(`Warmup failed with HTTP ${warmupResponse.status}`);
+		}
+
+		if (isRecordingSignal()) {
+			return speedTest().speedMbps;
+		}
+
+		const rttStart = performance.now();
+		const rttResponse = await fetchFn(targetUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ payload: "ping" }),
+			signal: controller.signal,
+		});
+		const baselineRttMs = performance.now() - rttStart;
+
+		if (!rttResponse.ok) {
+			throw new Error(`Latency probe returned HTTP ${rttResponse.status}`);
+		}
+
+		if (isRecordingSignal()) {
+			return speedTest().speedMbps;
+		}
+
+		const sampleBytes = 512 * 1024;
+		const sampleData = "a".repeat(sampleBytes);
+		const testPayload = JSON.stringify({
+			payload: sampleData,
+		});
+
+		const sampleCount = 2;
+		const measuredSpeeds: number[] = [];
+
+		for (let i = 0; i < sampleCount; i++) {
+			if (isRecordingSignal()) {
+				return speedTest().speedMbps;
+			}
+
+			const sampleStartTime = performance.now();
+			const response = await fetchFn(targetUrl, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: testPayload,
+				signal: controller.signal,
+			});
+			const rawDurationMs = performance.now() - sampleStartTime;
+
+			if (isRecordingSignal()) {
+				return speedTest().speedMbps;
+			}
+
+			if (!response.ok) {
+				throw new Error(`Speed test returned HTTP ${response.status}`);
+			}
+
+			const result = (await response.json()) as {
+				success?: boolean;
+				bytesReceived?: number;
+			};
+
+			if (!result.success || typeof result.bytesReceived !== "number") {
+				throw new Error("Invalid speed test server response");
+			}
+
+			if (result.bytesReceived < sampleBytes) {
+				throw new Error(
+					`Incomplete upload: expected ${sampleBytes} bytes, received ${result.bytesReceived}`,
+				);
+			}
+
+			const netDurationMs = Math.max(
+				10,
+				rawDurationMs - Math.min(baselineRttMs, rawDurationMs * 0.8),
+			);
+			measuredSpeeds.push(
+				calculateSpeedMbps(result.bytesReceived, netDurationMs),
+			);
+		}
+
+		const calculatedSpeed = Math.max(...measuredSpeeds);
+		const { qualityTier, recommendedResolution, recommendedLabel } =
+			determineQualityTierAndResolution(calculatedSpeed);
+
+		setSpeedTest({
+			status: "completed",
+			speedMbps: calculatedSpeed,
+			qualityTier,
+			recommendedResolution,
+			recommendedLabel,
+			lastTested: Date.now(),
+			error: null,
+		});
+
+		setNetworkHealth({
+			status: "healthy",
+			lastChecked: Date.now(),
+			error: null,
+		});
+
+		activeSpeedTestAbort = null;
+		return calculatedSpeed;
+	} catch (error) {
+		if (controller.signal.aborted) {
+			return speedTest().speedMbps;
+		}
+
+		const errorMessage =
+			error instanceof Error ? error.message : "Speed test failed";
+		setSpeedTest((prev) => ({
+			...prev,
+			status: "error",
+			error: errorMessage,
+		}));
+		activeSpeedTestAbort = null;
+		return null;
+	}
+}
+
+export function initNetworkHealthMonitoring(): () => void {
+	let isStopped = false;
+
+	void (async () => {
+		await runUploadHealthCheck();
+		if (!isStopped && !isRecordingSignal()) {
+			await runSpeedTest();
+		}
+	})();
+
+	const interval = setInterval(async () => {
+		if (isStopped || isRecordingSignal()) return;
+		if (networkHealth().status !== "healthy") {
+			await runUploadHealthCheck();
+		}
+		if (!isStopped && !isRecordingSignal()) {
+			await runSpeedTest();
+		}
+	}, 45_000);
+
+	return () => {
+		isStopped = true;
+		clearInterval(interval);
+		activeSpeedTestAbort?.abort();
+	};
+}
+
+export { networkHealth, speedTest };
diff --git a/apps/web/app/api/desktop/health/route.ts b/apps/web/app/api/desktop/health/route.ts
new file mode 100644
index 00000000000..84a8359aa02
--- /dev/null
+++ b/apps/web/app/api/desktop/health/route.ts
@@ -0,0 +1,129 @@
+import {
+	HttpApi,
+	HttpApiBuilder,
+	HttpApiEndpoint,
+	HttpApiError,
+	HttpApiGroup,
+} from "@effect/platform";
+import { Effect, Layer, Schema } from "effect";
+import { apiToHandler } from "@/lib/server";
+
+const MAX_PAYLOAD_BYTES = 1024 * 1024;
+const MAX_PAYLOAD_CHARS = 600 * 1024;
+const RATE_LIMIT_WINDOW_MS = 60_000;
+const RATE_LIMIT_MAX_REQUESTS = 60;
+
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
+
+function isRateLimited(ip: string): boolean {
+	const now = Date.now();
+	if (rateLimitMap.size > 5_000) {
+		for (const [k, v] of rateLimitMap) {
+			if (now > v.resetAt) rateLimitMap.delete(k);
+		}
+	}
+	const entry = rateLimitMap.get(ip);
+	if (!entry || now > entry.resetAt) {
+		rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_LIMIT_WINDOW_MS });
+		return false;
+	}
+	entry.count++;
+	return entry.count > RATE_LIMIT_MAX_REQUESTS;
+}
+
+const HealthResponse = Schema.Struct({
+	status: Schema.Literal("ok"),
+	timestamp: Schema.Number,
+});
+
+const SpeedTestPayload = Schema.Struct({
+	payload: Schema.String.pipe(
+		Schema.minLength(1),
+		Schema.maxLength(MAX_PAYLOAD_CHARS),
+	),
+});
+
+const SpeedTestResponse = Schema.Struct({
+	success: Schema.Boolean,
+	bytesReceived: Schema.Number,
+	timestamp: Schema.Number,
+});
+
+class DesktopHealthApi extends HttpApi.make("DesktopHealthApi").add(
+	HttpApiGroup.make("health")
+		.add(
+			HttpApiEndpoint.get("checkHealth")`/api/desktop/health`
+				.addSuccess(HealthResponse)
+				.addError(HttpApiError.InternalServerError),
+		)
+		.add(
+			HttpApiEndpoint.post("speedTest")`/api/desktop/health`
+				.setPayload(SpeedTestPayload)
+				.addSuccess(SpeedTestResponse)
+				.addError(HttpApiError.BadRequest)
+				.addError(HttpApiError.InternalServerError),
+		),
+) {}
+
+const ApiLive = HttpApiBuilder.api(DesktopHealthApi).pipe(
+	Layer.provide(
+		HttpApiBuilder.group(DesktopHealthApi, "health", (handlers) =>
+			handlers
+				.handle("checkHealth", () =>
+					Effect.succeed({
+						status: "ok" as const,
+						timestamp: Date.now(),
+					}),
+				)
+				.handle("speedTest", ({ payload }) => {
+					const bytes = Buffer.byteLength(payload.payload, "utf8");
+					return Effect.succeed({
+						success: true,
+						bytesReceived: bytes,
+						timestamp: Date.now(),
+					});
+				}),
+		),
+	),
+);
+
+const baseHandler = apiToHandler(ApiLive);
+
+export const GET = baseHandler;
+
+export const POST = async (req: Request) => {
+	const contentLengthHeader = req.headers.get("content-length");
+	if (!contentLengthHeader) {
+		return new Response(JSON.stringify({ error: "Length Required" }), {
+			status: 411,
+			headers: { "Content-Type": "application/json" },
+		});
+	}
+
+	const contentLength = Number.parseInt(contentLengthHeader, 10);
+	if (Number.isNaN(contentLength) || contentLength > MAX_PAYLOAD_BYTES) {
+		return new Response(JSON.stringify({ error: "Payload too large" }), {
+			status: 413,
+			headers: { "Content-Type": "application/json" },
+		});
+	}
+
+	const ip =
+		req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+		req.headers.get("x-real-ip") ||
+		"unknown";
+	if (isRateLimited(ip)) {
+		return new Response(
+			JSON.stringify({ error: "Too many speed test requests" }),
+			{
+				status: 429,
+				headers: {
+					"Content-Type": "application/json",
+					"Retry-After": "60",
+				},
+			},
+		);
+	}
+
+	return baseHandler(req);
+};