diff --git a/.cursor/setup-worktree-unix.sh b/.cursor/setup-worktree-unix.sh
new file mode 100755
index 000000000..09c1d8c92
--- /dev/null
+++ b/.cursor/setup-worktree-unix.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Shared git dir: fetch once, then sync local main and merge into this worktree's branch.
+git fetch origin main
+
+root="${ROOT_WORKTREE_PATH:?ROOT_WORKTREE_PATH is not set}"
+if ref="$(git -C "$root" symbolic-ref -q HEAD 2>/dev/null)" && [ "$ref" = "refs/heads/main" ]; then
+  git -C "$root" merge --ff-only origin/main
+else
+  git update-ref refs/heads/main origin/main
+fi
+
+git merge origin/main --no-edit
+
+vp install
diff --git a/.cursor/worktrees.json b/.cursor/worktrees.json
index 1e9fc58b6..ae877dc2d 100644
--- a/.cursor/worktrees.json
+++ b/.cursor/worktrees.json
@@ -1,3 +1,9 @@
 {
-  "setup-worktree": ["git fetch origin main", "git merge origin/main --no-edit", "vp install"]
+  "setup-worktree-unix": "setup-worktree-unix.sh",
+  "setup-worktree": [
+    "git fetch origin main",
+    "git update-ref refs/heads/main origin/main",
+    "git merge origin/main --no-edit",
+    "vp install"
+  ]
 }
diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 000000000..8ee47d0cc
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,21 @@
+# VC Müllheim Website
+
+Public website and admin app for VC Müllheim, including SAMS league data (matches, rankings, teams).
+
+## Language
+
+**Synced season**:
+The season UUID stored on team records by the teams sync, read from DynamoDB when loading matches.
+_Avoid_: Current season, live season
+
+**Effective match input**:
+The resolved query parameters (clubs, season, team, range, limit) used for cache keys and React Query after server-side resolution.
+_Avoid_: Hook options (implementation term), query params
+
+**Cache peek**:
+A DynamoDB-only read of cached SAMS data that never calls the external SAMS API during SSR navigation.
+_Avoid_: SSR fetch, preload
+
+**Configured club**:
+A sportsclub listed in project config whose `sportsclubUuid` is resolved from the SAMS clubs sync in DynamoDB.
+_Avoid_: Target club, default club
diff --git a/app/src/hooks/dataQueries.ts b/app/src/hooks/dataQueries.ts
index dcae8d6cd..a7a2d76df 100644
--- a/app/src/hooks/dataQueries.ts
+++ b/app/src/hooks/dataQueries.ts
@@ -5,8 +5,10 @@
 
 import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 import { z } from "zod";
-import type { LeagueMatchesResponse, RankingResponse } from "@/lambda/sams/types";
+import type { RankingResponse } from "@/lambda/sams/types";
 import type { PaginationCursor } from "@/lib/db/types";
+import type { SamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
+import { SAMS_MATCHES_CACHE_TTL_MS } from "@utils/sams-api";
 import { getEventByIdFn, getUpcomingEventsFn } from "../server/functions/events";
 import { listLocationsFn } from "../server/functions/locations";
 import { listMembersFn } from "../server/functions/members";
@@ -234,21 +236,12 @@ export const useSamsMatches = ({
   range,
   initialData,
   initialDataUpdatedAt,
-}: {
-  league?: string;
-  season?: string;
-  sportsclub?: string;
-  team?: string;
-  limit?: number;
-  range?: "past" | "future";
-  initialData?: LeagueMatchesResponse;
-  initialDataUpdatedAt?: number;
-} = {}) => {
+}: SamsMatchesHookOptions = {}) => {
   return useQuery({
     queryKey: ["samsMatches", league, season, sportsclub, team, limit, range],
     queryFn: () => getSamsMatchesFn({ data: { league, season, sportsclub, team, limit, range } }),
     retry: 1,
-    staleTime: 1000 * 60 * 2,
+    staleTime: SAMS_MATCHES_CACHE_TTL_MS,
     placeholderData: (previousData) => previousData,
     refetchOnWindowFocus: false,
     initialData,
diff --git a/app/src/routes/_layout/tabelle.tsx b/app/src/routes/_layout/tabelle.tsx
index ac9f724e4..f69679c46 100644
--- a/app/src/routes/_layout/tabelle.tsx
+++ b/app/src/routes/_layout/tabelle.tsx
@@ -7,7 +7,7 @@ import RankingTable from "@webapp/components/RankingTable";
 import { useSamsMatches } from "@webapp/hooks/dataQueries";
 import {
   listSamsTeamsFn,
-  peekSamsMatchesCacheFn,
+  loadSamsMatchesForSsrFn,
   peekSamsRankingsCacheFn,
 } from "@webapp/server/functions/sams";
 import { listTeamsFn } from "@webapp/server/functions/teams";
@@ -17,39 +17,15 @@ import {
   sortLeagueUuidsByLevels,
 } from "@webapp/utils/ranking";
 import { numToWord } from "num-words-de";
-import type { LeagueMatchesResponse, RankingResponse } from "@/lambda/sams/types";
+import type { RankingResponse } from "@/lambda/sams/types";
+import type { SamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
 
 const GAMES_PER_TEAM: number = 2.3; // maximum number of games per team to shown below the rankings
 
 export const Route = createFileRoute("/_layout/tabelle")({
   /**
-   * LOADING STRATEGY — do not change without understanding the full picture.
-   *
-   * Goal: instant navigation (no skeleton), with a small spinner showing when data
-   * is being refreshed in the background.
-   *
-   * How it works:
-   *  1. Loader runs server-side before navigation completes. It must be FAST — any
-   *     async call that hits an external API blocks the browser from showing the page.
-   *     → Use only DDB cache-peek functions (peekSamsRankingsCacheFn, peekSamsMatchesCacheFn).
-   *     → These read DynamoDB only, never call the SAMS API, and use Infinity TTL so they
-   *       always return whatever is cached regardless of age.
-   *
-   *  2. The loader passes the cached data as `initialData` + `initialDataUpdatedAt` to
-   *     React Query hooks. React Query compares `initialDataUpdatedAt` against its
-   *     `staleTime` (10 min). If the data is stale, it starts a background refetch
-   *     immediately after render → `isFetching: true` → small spinner in RankingTable.
-   *
-   *  3. The React Query `queryFn` (getSamsRankingsByLeagueUuidsFn) has its own 5-min
-   *     DDB cache check and falls back to the SAMS API on miss — this is the only place
-   *     the SAMS API is called.
-   *
-   * Result: users always see cached data instantly. The spinner appears when React Query
-   * decides fresh data is needed. A loading skeleton only appears when the DDB cache is
-   * completely empty (first-ever visit or after a full cache eviction).
-   *
-   * PITFALL: Do NOT replace peek functions with getSamsRankingsByLeagueUuidsFn in the
-   * loader. That function calls the SAMS API on cache miss, blocking navigation for 2-3s.
+   * SSR uses cache-peek only (loadSamsMatchesForSsrFn) — never getSamsMatchesFn in loaders.
+   * See docs/adr/0001-sams-match-loading.md.
    */
   loader: async () => {
     // Main data comes from DynamoDB; only a batched SAMS metadata lookup is used for league ordering.
@@ -62,7 +38,7 @@ export const Route = createFileRoute("/_layout/tabelle")({
         teams: teams.items,
         lastResultCap: 6,
         rankingsByLeagueUuid: {} satisfies Record<string, RankingResponse>,
-        matches: undefined,
+        matchesQueryOptions: undefined,
       };
     }
 
@@ -78,49 +54,41 @@ export const Route = createFileRoute("/_layout/tabelle")({
     const lastResultCap = calculateLastResultCap(samsTeams.teams.length, GAMES_PER_TEAM);
 
     let rankingsByLeagueUuid: Record<string, RankingResponse> = {};
-    let matches: LeagueMatchesResponse | undefined;
+    let matchesQueryOptions: SamsMatchesHookOptions | undefined;
     if (sortedLeagueUuids.length > 0) {
-      const [rankingsResult, matchesResult] = await Promise.all([
+      const matchesInput = { range: "past" as const, limit: lastResultCap };
+      const [rankingsResult, matchesSsr] = await Promise.allSettled([
         peekSamsRankingsCacheFn({ data: { leagueUuids: sortedLeagueUuids } }),
-        peekSamsMatchesCacheFn({ data: { range: "past", limit: lastResultCap } }),
+        loadSamsMatchesForSsrFn({ data: matchesInput }),
       ]);
-      rankingsByLeagueUuid = Object.fromEntries(rankingsResult.map((r) => [r.leagueUuid, r]));
-      matches = matchesResult ?? undefined;
+      if (rankingsResult.status === "fulfilled") {
+        rankingsByLeagueUuid = Object.fromEntries(
+          rankingsResult.value.map((r) => [r.leagueUuid, r]),
+        );
+      }
+      matchesQueryOptions =
+        matchesSsr.status === "fulfilled" ? matchesSsr.value.hookOptions : matchesInput;
     }
     return {
       leagueUuids: sortedLeagueUuids,
       teams: teams.items,
       lastResultCap,
       rankingsByLeagueUuid,
-      matches,
+      matchesQueryOptions,
     };
   },
   component: RouteComponent,
 });
 
 function RouteComponent() {
-  const {
-    leagueUuids,
-    teams,
-    lastResultCap,
-    rankingsByLeagueUuid,
-    matches: loaderMatches,
-  } = Route.useLoaderData();
-
-  const matchesInitialDataUpdatedAt = loaderMatches?.timestamp
-    ? new Date(loaderMatches.timestamp).getTime()
-    : undefined;
+  const { leagueUuids, teams, lastResultCap, rankingsByLeagueUuid, matchesQueryOptions } =
+    Route.useLoaderData();
 
   const {
     data: matchesData,
     isLoading: isLoadingMatches,
     isError: isMatchesError,
-  } = useSamsMatches({
-    range: "past",
-    limit: lastResultCap,
-    initialData: loaderMatches,
-    initialDataUpdatedAt: matchesInitialDataUpdatedAt,
-  });
+  } = useSamsMatches(matchesQueryOptions ?? { range: "past", limit: lastResultCap });
   const recentMatches = matchesData?.matches ?? [];
   const lastResultWord =
     recentMatches.length > 1 && numToWord(recentMatches.length, { uppercase: false });
diff --git a/app/src/routes/_layout/teams.$slug.tsx b/app/src/routes/_layout/teams.$slug.tsx
index 06b79c39e..016b7c670 100644
--- a/app/src/routes/_layout/teams.$slug.tsx
+++ b/app/src/routes/_layout/teams.$slug.tsx
@@ -34,14 +34,14 @@ import {
   useSamsMatches,
   useSamsRoster,
   useTeamBySlug,
-} from "@/app/src/hooks/dataQueries";
+} from "@webapp/hooks/dataQueries";
 import {
   listSamsTeamsFn,
-  peekSamsMatchesCacheFn,
+  loadSamsMatchesForSsrFn,
   peekSamsRankingsCacheFn,
-} from "@/app/src/server/functions/sams";
-import { getTeamBySlugFn } from "@/app/src/server/functions/teams";
-import type { LeagueMatchesResponse } from "@/lambda/sams/types";
+} from "@webapp/server/functions/sams";
+import { getTeamBySlugFn } from "@webapp/server/functions/teams";
+import type { SamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
 
 dayjs.locale(de);
 dayjs.extend(weekday);
@@ -55,23 +55,27 @@ export const Route = createFileRoute("/_layout/teams/$slug")({
     ]);
 
     if (!team) {
-      return { team: null, rankings: undefined, matches: undefined };
+      return { team: null, rankings: undefined, matchesQueryOptions: undefined };
     }
 
     const samsTeam = samsTeamsResult.teams.find((t) => t.uuid === team.sbvvTeamId);
 
     if (!samsTeam) {
-      return { team, samsTeam: undefined, rankings: undefined, matches: undefined };
+      return { team, samsTeam: undefined, rankings: undefined, matchesQueryOptions: undefined };
     }
 
-    const [rankings, matches] = await Promise.all([
+    const [rankingsResult, matchesSsr] = await Promise.allSettled([
       samsTeam.leagueUuid
         ? peekSamsRankingsCacheFn({ data: { leagueUuids: [samsTeam.leagueUuid] } })
         : Promise.resolve(undefined),
-      peekSamsMatchesCacheFn({ data: { team: samsTeam.uuid } }).then((m) => m ?? undefined),
+      loadSamsMatchesForSsrFn({ data: { team: samsTeam.uuid } }),
     ]);
 
-    return { team, samsTeam, rankings, matches };
+    const rankings = rankingsResult.status === "fulfilled" ? rankingsResult.value : undefined;
+    const matchesQueryOptions: SamsMatchesHookOptions =
+      matchesSsr.status === "fulfilled" ? matchesSsr.value.hookOptions : { team: samsTeam.uuid };
+
+    return { team, samsTeam, rankings, matchesQueryOptions };
   },
   component: RouteComponent,
 });
@@ -127,7 +131,10 @@ function RouteComponent() {
           <TeamCalendar slug={slug} loaderSamsTeam={loaderData.samsTeam} />
         </Suspense>
         <Suspense fallback={<CenteredLoader text="Lade Spielplan..." />}>
-          <TeamMatches loaderSamsTeam={loaderData.samsTeam} loaderMatches={loaderData.matches} />
+          <TeamMatches
+            loaderSamsTeam={loaderData.samsTeam}
+            matchesQueryOptions={loaderData.matchesQueryOptions}
+          />
         </Suspense>
         <Center>
           <Button component={Link} to="/#mannschaften">
@@ -168,20 +175,14 @@ function TeamCalendar({
 
 function TeamMatches({
   loaderSamsTeam,
-  loaderMatches,
+  matchesQueryOptions,
 }: {
   loaderSamsTeam: ReturnType<typeof Route.useLoaderData>["samsTeam"];
-  loaderMatches?: LeagueMatchesResponse;
+  matchesQueryOptions: SamsMatchesHookOptions | undefined;
 }) {
-  const matchesInitialDataUpdatedAt = loaderMatches?.timestamp
-    ? new Date(loaderMatches.timestamp).getTime()
-    : undefined;
-
-  const { data: matches, isLoading: isLoadingMatches } = useSamsMatches({
-    team: loaderSamsTeam?.uuid,
-    initialData: loaderMatches,
-    initialDataUpdatedAt: matchesInitialDataUpdatedAt,
-  });
+  const { data: matches, isLoading: isLoadingMatches } = useSamsMatches(
+    matchesQueryOptions ?? { team: loaderSamsTeam?.uuid },
+  );
 
   const currentMonth = dayjs().month() + 1;
   const isOffSeason = currentMonth >= 5 && currentMonth <= 9;
diff --git a/app/src/routes/_layout/termine.index.tsx b/app/src/routes/_layout/termine.index.tsx
index 13cd474e4..c428cfc82 100644
--- a/app/src/routes/_layout/termine.index.tsx
+++ b/app/src/routes/_layout/termine.index.tsx
@@ -6,33 +6,33 @@ import PageWithHeading from "@webapp/components/layout/PageWithHeading";
 import Matches from "@webapp/components/Matches";
 import { useSamsMatches } from "@webapp/hooks/dataQueries";
 import { getUpcomingEventsFn } from "@webapp/server/functions/events";
-import { peekSamsMatchesCacheFn } from "@webapp/server/functions/sams";
+import { loadSamsMatchesForSsrFn } from "@webapp/server/functions/sams";
 import { createWebcalLink } from "@webapp/utils/webcal";
 import dayjs from "dayjs";
 import { Fragment } from "react";
 import { FaBullhorn as IconSubscribe } from "react-icons/fa6";
-import type { LeagueMatchesResponse } from "@/lambda/sams/types";
+import type { SamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
 
 export const Route = createFileRoute("/_layout/termine/")({
   loader: async () => {
-    const [eventsResult, cachedMatchesResult] = await Promise.allSettled([
+    const [eventsResult, matchesSsr] = await Promise.allSettled([
       getUpcomingEventsFn(),
-      peekSamsMatchesCacheFn({ data: { range: "future" } }),
+      loadSamsMatchesForSsrFn({ data: { range: "future" } }),
     ]);
 
     const events = eventsResult.status === "fulfilled" ? eventsResult.value.items : [];
-    const matches =
-      cachedMatchesResult.status === "fulfilled"
-        ? (cachedMatchesResult.value ?? undefined)
-        : undefined;
+    const matchesQueryOptions =
+      matchesSsr.status === "fulfilled"
+        ? matchesSsr.value.hookOptions
+        : ({ range: "future" } satisfies SamsMatchesHookOptions);
 
-    return { events, matches };
+    return { events, matchesQueryOptions };
   },
   component: RouteComponent,
 });
 
 function RouteComponent() {
-  const { events, matches: loaderMatches } = Route.useLoaderData();
+  const { events, matchesQueryOptions } = Route.useLoaderData();
   const webcalLink = createWebcalLink("/ics/all.ics");
 
   return (
@@ -57,7 +57,7 @@ function RouteComponent() {
           </Stack>
         </Card>
         <EventsContent events={events} />
-        <MatchesContent loaderMatches={loaderMatches} />
+        <MatchesContent matchesQueryOptions={matchesQueryOptions} />
       </Stack>
     </PageWithHeading>
   );
@@ -86,19 +86,16 @@ function EventsContent({
   );
 }
 
-function MatchesContent({ loaderMatches }: { loaderMatches: LeagueMatchesResponse | undefined }) {
-  const matchesInitialDataUpdatedAt = loaderMatches?.timestamp
-    ? new Date(loaderMatches.timestamp).getTime()
-    : undefined;
+function MatchesContent({
+  matchesQueryOptions,
+}: {
+  matchesQueryOptions: SamsMatchesHookOptions | undefined;
+}) {
   const {
     data: matchesData,
     isLoading,
     isError,
-  } = useSamsMatches({
-    range: "future",
-    initialData: loaderMatches,
-    initialDataUpdatedAt: matchesInitialDataUpdatedAt,
-  });
+  } = useSamsMatches(matchesQueryOptions ?? { range: "future" });
 
   const currentMonth = dayjs().month() + 1;
   const isOffSeason = currentMonth >= 5 && currentMonth <= 9;
diff --git a/app/src/server/functions/sams-match-loader.server.test.ts b/app/src/server/functions/sams-match-loader.server.test.ts
new file mode 100644
index 000000000..ec4d35969
--- /dev/null
+++ b/app/src/server/functions/sams-match-loader.server.test.ts
@@ -0,0 +1,300 @@
+import type { ClubResponse, TeamResponse } from "@/lambda/sams/types";
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import {
+  loadSamsMatches,
+  readSamsMatchesCache,
+  resolveSamsMatchesEffectiveInput,
+  resolveSamsMatchesForSsr,
+  resolveSamsMatchesQuery,
+} from "./sams-match-loader.server";
+
+vi.mock("@codegen/sams/generated", () => ({
+  getAllLeagueMatches: vi.fn(),
+}));
+
+vi.mock("@webapp/server/queries", () => ({
+  getAllSamsClubs: vi.fn(),
+  getAllSamsTeams: vi.fn(),
+}));
+
+vi.mock("@webapp/server/ddb-cache", () => ({
+  readCacheEntry: vi.fn(),
+  writeCacheEntry: vi.fn(),
+}));
+
+import { getAllLeagueMatches } from "@codegen/sams/generated";
+import { readCacheEntry, writeCacheEntry } from "@webapp/server/ddb-cache";
+import { getAllSamsClubs, getAllSamsTeams } from "@webapp/server/queries";
+
+const mockGetAllLeagueMatches = vi.mocked(getAllLeagueMatches);
+const mockGetAllSamsClubs = vi.mocked(getAllSamsClubs);
+const mockGetAllSamsTeams = vi.mocked(getAllSamsTeams);
+const mockReadCacheEntry = vi.mocked(readCacheEntry);
+const mockWriteCacheEntry = vi.mocked(writeCacheEntry);
+
+const configuredClubs: ClubResponse[] = [
+  {
+    type: "club",
+    name: "VC Müllheim",
+    sportsclubUuid: "uuid-a",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  },
+  {
+    type: "club",
+    name: "Markgräfler Volleys",
+    sportsclubUuid: "uuid-b",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  },
+];
+
+describe("resolveSamsMatchesQuery", () => {
+  beforeEach(() => {
+    mockGetAllSamsClubs.mockReset();
+  });
+
+  it("skips default club resolution when team filter is set", async () => {
+    const result = await resolveSamsMatchesQuery({ team: "team-1", range: "future" });
+
+    expect(mockGetAllSamsClubs).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      team: "team-1",
+      range: "future",
+      effectiveSportsclubUuids: [],
+    });
+  });
+
+  it("returns null when configured clubs cannot be resolved", async () => {
+    mockGetAllSamsClubs.mockResolvedValue({ items: [], lastEvaluatedKey: undefined });
+
+    const result = await resolveSamsMatchesQuery({ range: "past" });
+
+    expect(result).toBeNull();
+  });
+
+  it("resolves configured sportsclub UUIDs for unscoped queries", async () => {
+    mockGetAllSamsClubs.mockResolvedValue({ items: configuredClubs });
+
+    const result = await resolveSamsMatchesQuery({ range: "future", limit: 10 });
+
+    expect(result?.effectiveSportsclubUuids.sort()).toEqual(["uuid-a", "uuid-b"]);
+    expect(result?.cacheKey).toContain("uuid-a");
+  });
+});
+
+const syncedTeam: TeamResponse = {
+  type: "team",
+  uuid: "team-1",
+  name: "VC Müllheim",
+  sportsclubUuid: "uuid-a",
+  associationUuid: "assoc-1",
+  leagueUuid: "league-1",
+  leagueName: "Bezirksliga",
+  seasonUuid: "season-synced",
+  seasonName: "2025/26",
+  updatedAt: "2026-01-01T00:00:00.000Z",
+};
+
+describe("readSamsMatchesCache season fallback", () => {
+  beforeEach(() => {
+    mockGetAllSamsClubs.mockReset();
+    mockGetAllSamsTeams.mockReset();
+    mockReadCacheEntry.mockReset();
+    mockGetAllSamsClubs.mockResolvedValue({ items: configuredClubs });
+  });
+
+  it("retries cache with synced season when the unscoped key misses", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({
+      items: [syncedTeam],
+      lastEvaluatedKey: undefined,
+    });
+    mockReadCacheEntry
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce({ matches: [], timestamp: "2026-07-21T08:00:00.000Z" });
+
+    const result = await readSamsMatchesCache({ range: "future" });
+
+    expect(result?.matches).toEqual([]);
+    expect(mockReadCacheEntry).toHaveBeenCalledTimes(2);
+    expect(mockReadCacheEntry.mock.calls[1]?.[0]).toContain("season-synced");
+  });
+
+  it("returns null when season sync fails and unscoped cache misses", async () => {
+    mockGetAllSamsTeams.mockRejectedValue(new Error("DynamoDB unavailable"));
+    mockReadCacheEntry.mockResolvedValue(null);
+
+    const result = await readSamsMatchesCache({ range: "future" });
+
+    expect(result).toBeNull();
+    expect(mockReadCacheEntry).toHaveBeenCalledTimes(1);
+  });
+
+  it("uses the unscoped cache entry without querying synced season", async () => {
+    const cached = { matches: [{ uuid: "match-1" }], timestamp: "2026-07-21T08:00:00.000Z" };
+    mockReadCacheEntry.mockResolvedValueOnce(cached);
+
+    const result = await readSamsMatchesCache({ range: "future" });
+
+    expect(result).toEqual(cached);
+    expect(mockGetAllSamsTeams).not.toHaveBeenCalled();
+    expect(mockReadCacheEntry).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("resolveSamsMatchesForSsr", () => {
+  beforeEach(() => {
+    mockGetAllSamsClubs.mockReset();
+    mockGetAllSamsTeams.mockReset();
+    mockReadCacheEntry.mockReset();
+    mockGetAllSamsClubs.mockResolvedValue({ items: configuredClubs });
+  });
+
+  it("includes synced season in effectiveInput when season-scoped cache is used", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({
+      items: [syncedTeam],
+      lastEvaluatedKey: undefined,
+    });
+    mockReadCacheEntry
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce({ matches: [], timestamp: "2026-07-21T08:00:00.000Z" });
+
+    const result = await resolveSamsMatchesForSsr({ range: "future" });
+
+    expect(result?.effectiveInput.season).toBe("season-synced");
+    expect(result?.effectiveInput.range).toBe("future");
+  });
+});
+
+describe("resolveSamsMatchesEffectiveInput", () => {
+  beforeEach(() => {
+    mockGetAllSamsClubs.mockReset();
+    mockGetAllSamsTeams.mockReset();
+    mockReadCacheEntry.mockReset();
+    mockGetAllSamsClubs.mockResolvedValue({ items: configuredClubs });
+  });
+
+  it("includes synced season without reading cache", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({
+      items: [syncedTeam],
+      lastEvaluatedKey: undefined,
+    });
+
+    const result = await resolveSamsMatchesEffectiveInput({ range: "future" });
+
+    expect(result).toMatchObject({ range: "future", season: "season-synced" });
+    expect(mockReadCacheEntry).not.toHaveBeenCalled();
+  });
+
+  it("returns null when configured clubs cannot be resolved", async () => {
+    mockGetAllSamsClubs.mockResolvedValue({ items: [], lastEvaluatedKey: undefined });
+
+    await expect(resolveSamsMatchesEffectiveInput({ range: "past" })).resolves.toBeNull();
+  });
+});
+
+describe("loadSamsMatches", () => {
+  beforeEach(() => {
+    mockGetAllSamsClubs.mockReset();
+    mockGetAllSamsTeams.mockReset();
+    mockReadCacheEntry.mockReset();
+    mockWriteCacheEntry.mockReset();
+    mockGetAllLeagueMatches.mockReset();
+    mockGetAllSamsClubs.mockResolvedValue({ items: configuredClubs });
+    mockReadCacheEntry.mockResolvedValue(null);
+    mockWriteCacheEntry.mockResolvedValue(undefined);
+  });
+
+  it("fetches without for-season when season sync fails", async () => {
+    mockGetAllSamsTeams.mockRejectedValue(new Error("DynamoDB unavailable"));
+    mockGetAllLeagueMatches.mockResolvedValue({
+      data: {
+        content: [{ uuid: "m1", date: "2026-02-01", results: null }],
+        last: true,
+      },
+      request: new Request("https://example.com/matches"),
+      response: new Response(),
+    });
+
+    await loadSamsMatches({ range: "future" });
+
+    expect(mockGetAllLeagueMatches).toHaveBeenCalled();
+    const query = mockGetAllLeagueMatches.mock.calls[0]?.[0]?.query;
+    expect(query?.["for-season"]).toBeUndefined();
+  });
+
+  it("returns season-scoped cache without calling the SAMS API", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({
+      items: [syncedTeam],
+      lastEvaluatedKey: undefined,
+    });
+    mockReadCacheEntry.mockResolvedValueOnce(null).mockResolvedValueOnce({
+      matches: [{ uuid: "cached-match", date: "2026-01-01", results: { winner: "a" } }],
+      timestamp: "2026-07-21T08:00:00.000Z",
+    });
+
+    const result = await loadSamsMatches({ range: "past" });
+
+    expect(result.matches).toHaveLength(1);
+    expect(mockGetAllLeagueMatches).not.toHaveBeenCalled();
+  });
+
+  it("writes cache after API fetch on cache miss", async () => {
+    mockGetAllSamsTeams.mockRejectedValue(new Error("DynamoDB unavailable"));
+    mockGetAllLeagueMatches.mockResolvedValue({
+      data: {
+        content: [{ uuid: "m1", date: "2026-01-10", results: { winner: "a" } }],
+        last: true,
+      },
+      request: new Request("https://example.com/matches"),
+      response: new Response(),
+    });
+
+    await loadSamsMatches({ range: "past", limit: 5 });
+
+    expect(mockWriteCacheEntry).toHaveBeenCalledTimes(1);
+    expect(mockGetAllLeagueMatches).toHaveBeenCalled();
+  });
+
+  it("calls the SAMS API with for-season when season sync succeeds on cache miss", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({
+      items: [syncedTeam],
+      lastEvaluatedKey: undefined,
+    });
+    mockGetAllLeagueMatches.mockResolvedValue({
+      data: {
+        content: [{ uuid: "m1", date: "2026-02-01", results: null }],
+        last: true,
+      },
+      request: new Request("https://example.com/matches"),
+      response: new Response(),
+    });
+
+    await loadSamsMatches({ range: "future" });
+
+    expect(mockGetAllLeagueMatches).toHaveBeenCalled();
+    const query = mockGetAllLeagueMatches.mock.calls[0]?.[0]?.query;
+    expect(query?.["for-season"]).toBe("season-synced");
+  });
+
+  it("continues pagination when a non-terminal page has empty content", async () => {
+    mockGetAllSamsTeams.mockResolvedValue({ items: [], lastEvaluatedKey: undefined });
+    mockGetAllLeagueMatches
+      .mockResolvedValueOnce({
+        data: { content: [], last: false },
+        request: new Request("https://example.com/matches?page=0"),
+        response: new Response(),
+      })
+      .mockResolvedValueOnce({
+        data: {
+          content: [{ uuid: "m2", date: "2026-02-02", results: null }],
+          last: true,
+        },
+        request: new Request("https://example.com/matches?page=1"),
+        response: new Response(),
+      });
+
+    const result = await loadSamsMatches({ team: "team-1", range: "future" });
+
+    expect(mockGetAllLeagueMatches).toHaveBeenCalledTimes(2);
+    expect(result.matches).toHaveLength(1);
+  });
+});
diff --git a/app/src/server/functions/sams-match-loader.server.ts b/app/src/server/functions/sams-match-loader.server.ts
new file mode 100644
index 000000000..1468db51c
--- /dev/null
+++ b/app/src/server/functions/sams-match-loader.server.ts
@@ -0,0 +1,341 @@
+/**
+ * Deep module for SAMS league match loading — club resolution, season fallback,
+ * cache read/write, API pagination, and post-fetch filtering.
+ *
+ * Match loading uses the **synced** seasonUuid from DynamoDB (teams sync output),
+ * not SAMS live currentSeason — see docs/adr/0001-sams-match-loading.md.
+ */
+
+import { getAllLeagueMatches, type LeagueMatchDto } from "@codegen/sams/generated";
+import * as Sentry from "@sentry/tanstackstart-react";
+import { createCacheKey } from "@utils/cache";
+import dayjs from "dayjs";
+import { filterAndSortSamsMatches } from "@utils/sams-match-filter";
+import { SAMS_API_TIMEOUT_MS, SAMS_MATCHES_CACHE_TTL_MS } from "@utils/sams-api";
+import type { SamsMatchesInput } from "@utils/sams-matches";
+import {
+  dedupeSamsMatchesByUuid,
+  resolveEffectiveSamsSportsclubUuids,
+  resolveSyncedSeasonUuidFromTeams,
+  shouldResolveDefaultSamsSportsclubs,
+} from "@utils/sams";
+import { type LeagueMatchesResponse, LeagueMatchesResponseSchema } from "@/lambda/sams/types";
+import { resolveConfiguredSamsClubsFromRecords } from "@/lib/sams/club-resolution";
+import { getAllSamsClubs, getAllSamsTeams } from "../queries";
+import { readCacheEntry, writeCacheEntry } from "../ddb-cache";
+import { parseServerData } from "../schema-parse";
+
+export type { SamsMatchesInput };
+
+const MATCHES_CACHE_TTL_MS = SAMS_MATCHES_CACHE_TTL_MS;
+
+type ResolvedSamsMatchesQuery = {
+  league?: string;
+  season?: string;
+  sportsclub?: string;
+  team?: string;
+  limit?: number;
+  range?: "past" | "future";
+  effectiveSportsclubUuids: string[];
+  cacheKey: string;
+};
+
+export type SamsMatchesForSsr = {
+  cached: LeagueMatchesResponse | null;
+  effectiveInput: SamsMatchesInput;
+};
+
+type CachedSamsMatchesLookup = {
+  activeQuery: ResolvedSamsMatchesQuery;
+  cached: LeagueMatchesResponse | null;
+};
+
+function toSamsMatchesInput(
+  query: ResolvedSamsMatchesQuery,
+  data?: SamsMatchesInput,
+): SamsMatchesInput {
+  return {
+    league: query.league ?? data?.league,
+    season: query.season ?? data?.season,
+    sportsclub: query.sportsclub ?? data?.sportsclub,
+    team: query.team ?? data?.team,
+    limit: query.limit ?? data?.limit,
+    range: query.range ?? data?.range,
+  };
+}
+
+async function resolveConfiguredSamsSportsclubUuidsFromStorage(): Promise<string[]> {
+  const { items } = await getAllSamsClubs();
+  const { sportsclubUuids, missingClubSlugs } = resolveConfiguredSamsClubsFromRecords(items);
+
+  if (missingClubSlugs.length > 0) {
+    console.warn("Failed to resolve configured SAMS clubs", { missingClubSlugs });
+  }
+
+  return sportsclubUuids;
+}
+
+export function createSamsMatchesCacheKey(
+  input: SamsMatchesInput,
+  sportsclubUuids: readonly string[],
+): string {
+  return createCacheKey({
+    type: "sams_matches",
+    league: input.league,
+    season: input.season,
+    sportsclubUuids,
+    team: input.team,
+    limit: input.limit,
+    range: input.range,
+  });
+}
+
+async function resolveSyncedSeasonUuid(): Promise<string | undefined> {
+  try {
+    const syncedTeams = await getAllSamsTeams();
+    return resolveSyncedSeasonUuidFromTeams(syncedTeams.items, {
+      onDisagreement: (seasonUuids) => {
+        console.warn("Synced SAMS teams disagree on season UUID", { seasonUuids });
+      },
+    });
+  } catch (error) {
+    console.warn("Failed to resolve synced SAMS season UUID; continuing without season filter", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return undefined;
+  }
+}
+
+/** Resolves effective SAMS match query params and cache key (without auto season lookup). */
+export async function resolveSamsMatchesQuery(
+  data?: SamsMatchesInput,
+): Promise<ResolvedSamsMatchesQuery | null> {
+  const { league, season, sportsclub, team } = data || {};
+
+  const shouldUseDefaultSportsclubs = shouldResolveDefaultSamsSportsclubs({
+    league,
+    sportsclub,
+    team,
+  });
+  const defaultSportsclubUuids = shouldUseDefaultSportsclubs
+    ? await resolveConfiguredSamsSportsclubUuidsFromStorage()
+    : [];
+  if (shouldUseDefaultSportsclubs && defaultSportsclubUuids.length === 0) {
+    return null;
+  }
+
+  const effectiveSportsclubUuids = resolveEffectiveSamsSportsclubUuids(
+    { league, sportsclub, team },
+    defaultSportsclubUuids,
+  );
+
+  const cacheKey = createSamsMatchesCacheKey(
+    {
+      league,
+      season,
+      sportsclub,
+      team,
+      limit: data?.limit,
+      range: data?.range,
+    },
+    effectiveSportsclubUuids,
+  );
+
+  return {
+    league,
+    season,
+    sportsclub,
+    team,
+    limit: data?.limit,
+    range: data?.range,
+    effectiveSportsclubUuids,
+    cacheKey,
+  };
+}
+
+async function resolveSeasonScopedSamsMatchesQuery(
+  data: SamsMatchesInput | undefined,
+  baseQuery: ResolvedSamsMatchesQuery,
+): Promise<ResolvedSamsMatchesQuery | null> {
+  if (baseQuery.season) return baseQuery;
+
+  const syncedSeason = await resolveSyncedSeasonUuid();
+  if (!syncedSeason) return null;
+
+  return resolveSamsMatchesQuery({ ...data, season: syncedSeason });
+}
+
+/** Resolves effective match query params without cache or SAMS API (for SSR fallbacks). */
+export async function resolveSamsMatchesEffectiveInput(
+  data?: SamsMatchesInput,
+): Promise<SamsMatchesInput | null> {
+  const resolvedQuery = await resolveSamsMatchesQuery(data);
+  if (!resolvedQuery) return null;
+
+  const seasonScopedQuery = resolvedQuery.season
+    ? resolvedQuery
+    : await resolveSeasonScopedSamsMatchesQuery(data, resolvedQuery);
+
+  return toSamsMatchesInput(seasonScopedQuery ?? resolvedQuery, data);
+}
+
+async function readCachedSamsMatchesWithSeasonFallback(
+  data: SamsMatchesInput | undefined,
+  resolvedQuery: ResolvedSamsMatchesQuery,
+  maxAgeMs: number,
+): Promise<CachedSamsMatchesLookup> {
+  let activeQuery = resolvedQuery;
+  let cached = await readCacheEntry<LeagueMatchesResponse>(activeQuery.cacheKey, maxAgeMs);
+  if (!cached) {
+    const seasonScopedQuery = await resolveSeasonScopedSamsMatchesQuery(data, resolvedQuery);
+    if (seasonScopedQuery) {
+      activeQuery = seasonScopedQuery;
+      cached = await readCacheEntry<LeagueMatchesResponse>(activeQuery.cacheKey, maxAgeMs);
+    }
+  }
+
+  return { activeQuery, cached };
+}
+
+async function fetchAllSamsLeagueMatches({
+  league,
+  season,
+  team,
+  sportsclubUuids,
+}: Pick<SamsMatchesInput, "league" | "season" | "team"> & {
+  sportsclubUuids: readonly string[];
+}): Promise<Omit<LeagueMatchDto, "_links">[]> {
+  const sportsclubFilters = sportsclubUuids.length > 0 ? sportsclubUuids : [undefined];
+  const allMatches: Omit<LeagueMatchDto, "_links">[] = [];
+
+  for (const sportsclubUuid of sportsclubFilters) {
+    const defaultQueryParams: Record<string, string> = {};
+    if (league) defaultQueryParams["for-league"] = league;
+    if (season) defaultQueryParams["for-season"] = season;
+    if (sportsclubUuid) defaultQueryParams["for-sportsclub"] = sportsclubUuid;
+    if (team) defaultQueryParams["for-team"] = team;
+
+    let currentPage = 0;
+    let hasMorePages = true;
+
+    while (hasMorePages) {
+      const { data: pageData } = await getAllLeagueMatches({
+        query: { ...defaultQueryParams, page: currentPage, size: 100 },
+        signal: AbortSignal.timeout(SAMS_API_TIMEOUT_MS),
+      });
+
+      if (!pageData) {
+        if (currentPage === 0) {
+          console.warn("SAMS API returned no data on first page", {
+            page: currentPage,
+            sportsclubUuid,
+            league,
+            season,
+            team,
+          });
+          Sentry.metrics.count("sams.league_matches.empty_response", 1, {
+            attributes: {
+              page: String(currentPage),
+              sportsclub_uuid: sportsclubUuid ?? "",
+              league: league ?? "",
+              season: season ?? "",
+              team: team ?? "",
+            },
+          });
+        }
+        break;
+      }
+
+      if (pageData.content?.length) {
+        allMatches.push(...pageData.content.map(({ _links: _, ...match }) => match));
+      }
+
+      if (pageData.last === true) {
+        hasMorePages = false;
+      } else {
+        currentPage++;
+      }
+    }
+  }
+
+  return dedupeSamsMatchesByUuid(allMatches);
+}
+
+function emptyMatchesResponse(): LeagueMatchesResponse {
+  return parseServerData(
+    LeagueMatchesResponseSchema,
+    { matches: [], timestamp: dayjs().toISOString() },
+    "Failed to parse empty SAMS matches response",
+  );
+}
+
+/** Loads league matches — cache first, then SAMS API on miss. May block on external API. */
+export async function loadSamsMatches(data?: SamsMatchesInput): Promise<LeagueMatchesResponse> {
+  const resolvedQuery = await resolveSamsMatchesQuery(data);
+  if (!resolvedQuery) {
+    console.warn("No configured SAMS sportsclub UUIDs resolved; returning empty matches", {
+      league: data?.league,
+      season: data?.season,
+    });
+    return emptyMatchesResponse();
+  }
+
+  const { activeQuery, cached: cachedMatches } = await readCachedSamsMatchesWithSeasonFallback(
+    data,
+    resolvedQuery,
+    MATCHES_CACHE_TTL_MS,
+  );
+
+  const { league, season, team, cacheKey, effectiveSportsclubUuids } = activeQuery;
+  if (cachedMatches) return cachedMatches;
+
+  const allMatches = await fetchAllSamsLeagueMatches({
+    league,
+    season,
+    team,
+    sportsclubUuids: effectiveSportsclubUuids,
+  });
+
+  const result = parseServerData(
+    LeagueMatchesResponseSchema,
+    {
+      matches: filterAndSortSamsMatches(allMatches, data),
+      timestamp: dayjs().toISOString(),
+    },
+    "Failed to parse SAMS matches response",
+  );
+  await writeCacheEntry(cacheKey, result);
+  return result;
+}
+
+/**
+ * Resolves cached matches plus effective query params for SSR (includes synced season when used).
+ */
+export async function resolveSamsMatchesForSsr(
+  data?: SamsMatchesInput,
+): Promise<SamsMatchesForSsr | null> {
+  const resolvedQuery = await resolveSamsMatchesQuery(data);
+  if (!resolvedQuery) return null;
+
+  const { activeQuery, cached } = await readCachedSamsMatchesWithSeasonFallback(
+    data,
+    resolvedQuery,
+    Infinity,
+  );
+
+  return {
+    cached,
+    effectiveInput: toSamsMatchesInput(activeQuery, data),
+  };
+}
+
+/** Cache read only — DynamoDB, no SAMS API. For explicit cache-peek RPCs. */
+export async function readSamsMatchesCache(
+  data?: SamsMatchesInput,
+): Promise<LeagueMatchesResponse | null> {
+  const resolvedQuery = await resolveSamsMatchesQuery(data);
+  if (!resolvedQuery) return null;
+
+  const { cached } = await readCachedSamsMatchesWithSeasonFallback(data, resolvedQuery, Infinity);
+  return cached;
+}
diff --git a/app/src/server/functions/sams-ssr.server.test.ts b/app/src/server/functions/sams-ssr.server.test.ts
new file mode 100644
index 000000000..1ba00c2b6
--- /dev/null
+++ b/app/src/server/functions/sams-ssr.server.test.ts
@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+vi.mock("./sams-match-loader.server", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./sams-match-loader.server")>();
+  return {
+    ...actual,
+    resolveSamsMatchesForSsr: vi.fn(),
+    resolveSamsMatchesEffectiveInput: vi.fn(),
+  };
+});
+
+import {
+  resolveSamsMatchesEffectiveInput,
+  resolveSamsMatchesForSsr,
+} from "./sams-match-loader.server";
+import { handleLoadSamsMatchesForSsr } from "./sams.server";
+
+const mockResolveSamsMatchesForSsr = vi.mocked(resolveSamsMatchesForSsr);
+const mockResolveSamsMatchesEffectiveInput = vi.mocked(resolveSamsMatchesEffectiveInput);
+
+describe("handleLoadSamsMatchesForSsr", () => {
+  beforeEach(() => {
+    mockResolveSamsMatchesForSsr.mockReset();
+    mockResolveSamsMatchesEffectiveInput.mockReset();
+  });
+
+  it("returns hookOptions from a successful cache peek", async () => {
+    mockResolveSamsMatchesForSsr.mockResolvedValue({
+      cached: { matches: [], timestamp: "2026-07-21T08:00:00.000Z" },
+      effectiveInput: { range: "future", season: "season-synced" },
+    });
+
+    const result = await handleLoadSamsMatchesForSsr({ range: "future" });
+
+    expect(result.hookOptions).toMatchObject({
+      range: "future",
+      season: "season-synced",
+      initialData: { matches: [], timestamp: "2026-07-21T08:00:00.000Z" },
+    });
+    expect(mockResolveSamsMatchesEffectiveInput).not.toHaveBeenCalled();
+  });
+
+  it("falls back to effective input when cache peek throws", async () => {
+    mockResolveSamsMatchesForSsr.mockRejectedValue(new Error("DynamoDB unavailable"));
+    mockResolveSamsMatchesEffectiveInput.mockResolvedValue({
+      range: "past",
+      limit: 10,
+      season: "season-synced",
+    });
+
+    const result = await handleLoadSamsMatchesForSsr({ range: "past", limit: 10 });
+
+    expect(mockResolveSamsMatchesEffectiveInput).toHaveBeenCalledWith({ range: "past", limit: 10 });
+    expect(result.cached).toBeUndefined();
+    expect(result.hookOptions).toMatchObject({
+      range: "past",
+      limit: 10,
+      season: "season-synced",
+    });
+  });
+
+  it("uses raw input when cache peek and effective input resolution both fail", async () => {
+    mockResolveSamsMatchesForSsr.mockRejectedValue(new Error("DynamoDB unavailable"));
+    mockResolveSamsMatchesEffectiveInput.mockResolvedValue(null);
+
+    const result = await handleLoadSamsMatchesForSsr({ team: "team-1" });
+
+    expect(result.hookOptions).toMatchObject({ team: "team-1" });
+    expect(result.cached).toBeUndefined();
+  });
+});
diff --git a/app/src/server/functions/sams.server.ts b/app/src/server/functions/sams.server.ts
index c491e226a..1190e4113 100644
--- a/app/src/server/functions/sams.server.ts
+++ b/app/src/server/functions/sams.server.ts
@@ -5,24 +5,19 @@
  * Server function wrappers live in `sams.ts`; tests import helpers from here.
  */
 
-import {
-  getAllLeagueMatches,
-  getLeagueByUuid,
-  getRankingsForLeague,
-  getSeasonByUuid,
-  type LeagueMatchDto,
-} from "@codegen/sams/generated";
+import { getLeagueByUuid, getRankingsForLeague, getSeasonByUuid } from "@codegen/sams/generated";
 import { InvokeCommand, LambdaClient } from "@aws-sdk/client-lambda";
-import * as Sentry from "@sentry/tanstackstart-react";
 import { createCacheKey, createExpiringCache, getOrSetExpiringCacheValue } from "@utils/cache";
 import dayjs from "dayjs";
+import { SAMS_API_TIMEOUT_MS } from "@utils/sams-api";
+import type { SamsMatchesInput } from "@utils/sams-matches";
+import { buildSamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
 import { z } from "zod";
 import {
-  type LeagueMatchesResponse,
-  LeagueMatchesResponseSchema,
   type LiveMatch,
   type LiveTickerResponse,
   LiveTickerResponseSchema,
+  type LeagueMatchesResponse,
   type RankingResponse,
   RankingResponseSchema,
 } from "@/lambda/sams/types";
@@ -37,210 +32,18 @@ import {
 import { readCacheEntry, writeCacheEntry } from "../ddb-cache";
 import { parseServerData } from "../schema-parse";
 import {
-  dedupeSamsMatchesByUuid,
-  SAMS_TARGET_CLUB_SLUGS,
-  shouldResolveDefaultSamsSportsclubs,
-} from "@/utils/sams";
-import { buildLeagueOrderingContext } from "@webapp/utils/ranking";
+  loadSamsMatches,
+  readSamsMatchesCache,
+  resolveSamsMatchesEffectiveInput,
+  resolveSamsMatchesForSsr,
+} from "./sams-match-loader.server";
 
 const MEDIA_CLOUDFRONT_URL = () => process.env.MEDIA_CLOUDFRONT_URL || "";
 
-const SAMS_API_TIMEOUT_MS = 10_000;
-
-export type SamsMatchesInput = {
-  league?: string;
-  season?: string;
-  sportsclub?: string;
-  team?: string;
-  limit?: number;
-  range?: "past" | "future";
-};
-
-async function resolveConfiguredSamsSportsclubUuidsFromStorage(): Promise<string[]> {
-  const configuredClubs = await Promise.all(
-    SAMS_TARGET_CLUB_SLUGS.map(async (clubSlug) => ({
-      clubSlug,
-      club: await getSamsClubByNameSlug(clubSlug),
-    })),
-  );
-
-  const missingClubSlugs = configuredClubs
-    .filter(({ club }) => !club?.sportsclubUuid)
-    .map(({ clubSlug }) => clubSlug);
-
-  if (missingClubSlugs.length > 0) {
-    console.warn("Failed to resolve configured SAMS clubs", { missingClubSlugs });
-  }
-
-  return configuredClubs.flatMap(({ club }) => (club?.sportsclubUuid ? [club.sportsclubUuid] : []));
-}
-
-export function resolveEffectiveSamsSportsclubUuids(
-  input: Pick<SamsMatchesInput, "league" | "sportsclub" | "team">,
-  defaultSportsclubUuids: readonly string[],
-): string[] {
-  if (input.sportsclub) return [input.sportsclub];
-  if (!shouldResolveDefaultSamsSportsclubs(input)) return [];
-  return [...defaultSportsclubUuids];
-}
-
-export function createSamsMatchesCacheKey(
-  input: SamsMatchesInput,
-  sportsclubUuids: readonly string[],
-): string {
-  return createCacheKey({
-    type: "sams_matches",
-    league: input.league,
-    season: input.season,
-    sportsclubUuids,
-    team: input.team,
-    limit: input.limit,
-    range: input.range,
-  });
-}
-
-type ResolvedSamsMatchesQuery = {
-  league?: string;
-  season?: string;
-  sportsclub?: string;
-  team?: string;
-  limit?: number;
-  range?: "past" | "future";
-  effectiveSportsclubUuids: string[];
-  cacheKey: string;
-};
-
-async function resolveSyncedSeasonUuid(): Promise<string | undefined> {
-  try {
-    const syncedTeams = await getAllSamsTeams();
-    return buildLeagueOrderingContext(syncedTeams.items).seasonUuid;
-  } catch (error) {
-    console.warn("Failed to resolve synced SAMS season UUID; continuing without season filter", {
-      error: error instanceof Error ? error.message : String(error),
-    });
-    return undefined;
-  }
-}
-
-/** Resolves effective SAMS match query params and cache key (without auto season lookup). */
-export async function resolveSamsMatchesQuery(
-  data?: SamsMatchesInput,
-): Promise<ResolvedSamsMatchesQuery | null> {
-  const { league, season, sportsclub, team } = data || {};
-
-  const shouldUseDefaultSportsclubs = shouldResolveDefaultSamsSportsclubs({
-    league,
-    sportsclub,
-    team,
-  });
-  const defaultSportsclubUuids = shouldUseDefaultSportsclubs
-    ? await resolveConfiguredSamsSportsclubUuidsFromStorage()
-    : [];
-  if (shouldUseDefaultSportsclubs && defaultSportsclubUuids.length === 0) {
-    return null;
-  }
-
-  const effectiveSportsclubUuids = resolveEffectiveSamsSportsclubUuids(
-    { league, sportsclub, team },
-    defaultSportsclubUuids,
-  );
-
-  const cacheKey = createSamsMatchesCacheKey(
-    {
-      league,
-      season,
-      sportsclub,
-      team,
-      limit: data?.limit,
-      range: data?.range,
-    },
-    effectiveSportsclubUuids,
-  );
-
-  return {
-    league,
-    season,
-    sportsclub,
-    team,
-    limit: data?.limit,
-    range: data?.range,
-    effectiveSportsclubUuids,
-    cacheKey,
-  };
-}
-
-async function resolveSeasonScopedSamsMatchesQuery(
-  data: SamsMatchesInput | undefined,
-  baseQuery: ResolvedSamsMatchesQuery,
-): Promise<ResolvedSamsMatchesQuery | null> {
-  if (baseQuery.season) return baseQuery;
+export type { SamsMatchesInput };
 
-  const syncedSeason = await resolveSyncedSeasonUuid();
-  if (!syncedSeason) return null;
-
-  return resolveSamsMatchesQuery({ ...data, season: syncedSeason });
-}
-
-async function fetchAllSamsLeagueMatches({
-  league,
-  season,
-  team,
-  sportsclubUuids,
-}: Pick<SamsMatchesInput, "league" | "season" | "team"> & {
-  sportsclubUuids: readonly string[];
-}): Promise<Omit<LeagueMatchDto, "_links">[]> {
-  const sportsclubFilters = sportsclubUuids.length > 0 ? sportsclubUuids : [undefined];
-  const allMatches: Omit<LeagueMatchDto, "_links">[] = [];
-
-  for (const sportsclubUuid of sportsclubFilters) {
-    const defaultQueryParams: Record<string, string> = {};
-    if (league) defaultQueryParams["for-league"] = league;
-    if (season) defaultQueryParams["for-season"] = season;
-    if (sportsclubUuid) defaultQueryParams["for-sportsclub"] = sportsclubUuid;
-    if (team) defaultQueryParams["for-team"] = team;
-
-    let currentPage = 0;
-    let hasMorePages = true;
-
-    while (hasMorePages) {
-      const { data: pageData } = await getAllLeagueMatches({
-        query: { ...defaultQueryParams, page: currentPage, size: 100 },
-        signal: AbortSignal.timeout(SAMS_API_TIMEOUT_MS),
-      });
-
-      if (!pageData) {
-        if (currentPage === 0) {
-          console.warn("SAMS API returned no data on first page", {
-            page: currentPage,
-            sportsclubUuid,
-            league,
-            season,
-            team,
-          });
-          Sentry.metrics.count("sams.league_matches.empty_response", 1, {
-            attributes: {
-              page: String(currentPage),
-              sportsclub_uuid: sportsclubUuid ?? "",
-              league: league ?? "",
-              season: season ?? "",
-              team: team ?? "",
-            },
-          });
-        }
-        break;
-      }
-
-      if (pageData.content) {
-        allMatches.push(...pageData.content.map(({ _links: _, ...match }) => match));
-        currentPage++;
-      }
-
-      if (pageData.last === true) hasMorePages = false;
-    }
-  }
-
-  return dedupeSamsMatchesByUuid(allMatches);
-}
+export const handleGetSamsMatches = loadSamsMatches;
+export const handleReadSamsMatchesCache = readSamsMatchesCache;
 
 async function fetchSamsRankingsByLeagueUuid(leagueUuid: string): Promise<RankingResponse> {
   const cacheKey = createCacheKey({ type: "sams_rankings", leagueUuid });
@@ -278,7 +81,7 @@ async function fetchSamsRankingsByLeagueUuid(leagueUuid: string): Promise<Rankin
     RankingResponseSchema,
     {
       teams: rankingsData.content,
-      timestamp: new Date().toISOString(),
+      timestamp: dayjs().toISOString(),
       leagueUuid,
       leagueName,
       seasonName,
@@ -292,70 +95,6 @@ async function fetchSamsRankingsByLeagueUuid(leagueUuid: string): Promise<Rankin
 
 // ── SAMS API proxy — Matches ─────────────────────────────────────────────────
 
-export async function handleGetSamsMatches(data?: SamsMatchesInput) {
-  const resolvedQuery = await resolveSamsMatchesQuery(data);
-  if (!resolvedQuery) {
-    console.warn("No configured SAMS sportsclub UUIDs resolved; returning empty matches", {
-      league: data?.league,
-      season: data?.season,
-    });
-    return parseServerData(
-      LeagueMatchesResponseSchema,
-      { matches: [], timestamp: new Date().toISOString() },
-      "Failed to parse empty SAMS matches response",
-    );
-  }
-
-  let activeQuery = resolvedQuery;
-  let cachedMatches = await readCacheEntry<LeagueMatchesResponse>(
-    activeQuery.cacheKey,
-    5 * 60 * 1000,
-  );
-  if (!cachedMatches) {
-    const seasonScopedQuery = await resolveSeasonScopedSamsMatchesQuery(data, resolvedQuery);
-    if (seasonScopedQuery) {
-      activeQuery = seasonScopedQuery;
-      cachedMatches = await readCacheEntry<LeagueMatchesResponse>(
-        activeQuery.cacheKey,
-        5 * 60 * 1000,
-      );
-    }
-  }
-
-  const { league, season, team, cacheKey, effectiveSportsclubUuids } = activeQuery;
-  if (cachedMatches) return cachedMatches;
-
-  const allMatches = await fetchAllSamsLeagueMatches({
-    league,
-    season,
-    team,
-    sportsclubUuids: effectiveSportsclubUuids,
-  });
-
-  let filteredMatches = allMatches;
-  if (data?.range === "future") {
-    filteredMatches = allMatches.filter((m) => !m.results?.winner);
-    filteredMatches.sort((a, b) =>
-      !a.date ? 1 : !b.date ? -1 : dayjs(a.date).isBefore(dayjs(b.date)) ? -1 : 1,
-    );
-  } else if (data?.range === "past") {
-    filteredMatches = allMatches.filter((m) => !!m.results?.winner);
-    filteredMatches.sort((a, b) =>
-      !a.date ? 1 : !b.date ? -1 : dayjs(a.date).isAfter(dayjs(b.date)) ? -1 : 1,
-    );
-  }
-
-  if (data?.limit) filteredMatches = filteredMatches.slice(0, data.limit);
-
-  const result = parseServerData(
-    LeagueMatchesResponseSchema,
-    { matches: filteredMatches, timestamp: new Date().toISOString() },
-    "Failed to parse SAMS matches response",
-  );
-  await writeCacheEntry(cacheKey, result);
-  return result;
-}
-
 // ── SAMS API proxy — Rankings ────────────────────────────────────────────────
 
 export async function handleGetSamsRankingsByLeagueUuids(leagueUuids: string[]) {
@@ -381,25 +120,27 @@ export async function handlePeekSamsRankingsCache(leagueUuids: string[]) {
   return results.filter((r): r is RankingResponse => r !== null);
 }
 
-/**
- * Cache-peek-only variant for matches: resolves the effective filter params (including the
- * default sportsclub UUID) and returns the cached entry if present, otherwise null.
- * Use in route loaders to keep navigation fast — React Query will fetch live data client-side.
- */
-export async function handlePeekSamsMatchesCache(data?: SamsMatchesInput) {
-  const resolvedQuery = await resolveSamsMatchesQuery(data);
-  if (!resolvedQuery) return null;
-
-  const cachedMatches = await readCacheEntry<LeagueMatchesResponse>(
-    resolvedQuery.cacheKey,
-    Infinity,
-  );
-  if (cachedMatches) return cachedMatches;
+/** Peek-only SSR loader bundle — returns hook options for useSamsMatches. */
+export async function handleLoadSamsMatchesForSsr(input?: SamsMatchesInput) {
+  let cached: LeagueMatchesResponse | undefined;
+  let effectiveInput: SamsMatchesInput;
 
-  const seasonScopedQuery = await resolveSeasonScopedSamsMatchesQuery(data, resolvedQuery);
-  if (!seasonScopedQuery) return null;
+  try {
+    const resolved = await resolveSamsMatchesForSsr(input);
+    cached = resolved?.cached ?? undefined;
+    effectiveInput =
+      resolved?.effectiveInput ?? (await resolveSamsMatchesEffectiveInput(input)) ?? input ?? {};
+  } catch (error) {
+    console.warn("SAMS SSR match load failed; using effective input without cache", {
+      error: error instanceof Error ? error.message : String(error),
+    });
+    effectiveInput = (await resolveSamsMatchesEffectiveInput(input)) ?? input ?? {};
+  }
 
-  return readCacheEntry<LeagueMatchesResponse>(seasonScopedQuery.cacheKey, Infinity);
+  return {
+    cached,
+    hookOptions: buildSamsMatchesHookOptions(effectiveInput, cached ?? null),
+  };
 }
 
 export async function handleListSamsClubs() {
@@ -592,7 +333,7 @@ export async function handleGetSamsTicker() {
           LiveTickerResponseSchema,
           {
             liveMatches,
-            timestamp: new Date().toISOString(),
+            timestamp: dayjs().toISOString(),
           },
           "Failed to parse SAMS live ticker response",
         ),
diff --git a/app/src/server/functions/sams.test.ts b/app/src/server/functions/sams.test.ts
index 3c36f3466..7683bd0dd 100644
--- a/app/src/server/functions/sams.test.ts
+++ b/app/src/server/functions/sams.test.ts
@@ -1,13 +1,9 @@
 import { InvokeCommand, LambdaClient } from "@aws-sdk/client-lambda";
 import { mockClient } from "aws-sdk-client-mock";
 import { beforeEach, describe, expect, it } from "vite-plus/test";
-import {
-  buildLiveMatchesFromRaw,
-  createSamsMatchesCacheKey,
-  invokeSamsLambdaAsync,
-  resolveEffectiveSamsSportsclubUuids,
-  resolveClubLogoUrl,
-} from "./sams.server";
+import { resolveEffectiveSamsSportsclubUuids } from "@utils/sams";
+import { createSamsMatchesCacheKey } from "./sams-match-loader.server";
+import { buildLiveMatchesFromRaw, invokeSamsLambdaAsync, resolveClubLogoUrl } from "./sams.server";
 import { triggerSamsClubsSyncFn, triggerSamsTeamsSyncFn } from "./sams";
 
 describe("resolveClubLogoUrl", () => {
diff --git a/app/src/server/functions/sams.ts b/app/src/server/functions/sams.ts
index dd6eb2caf..4df659846 100644
--- a/app/src/server/functions/sams.ts
+++ b/app/src/server/functions/sams.ts
@@ -1,12 +1,13 @@
 /**
- * SAMS server functions — replaces lib/trpc/routers/samsClubs.ts + samsTeams.ts
- * plus the read lambdas from SamsStack (matches, rankings).
+ * SAMS server functions for read and sync triggers.
+ * Read paths use server functions in this app; sync runs via scheduled Lambdas.
  *
- * Server-only logic lives in sams.server.ts (import-protected). This file exports
- * createServerFn wrappers that are safe to import from client code.
+ * Server-only logic lives in `sams.server.ts` and `sams-match-loader.server.ts`
+ * (import-protected). This file exports createServerFn wrappers safe for client code.
  */
 
 import { createServerFn } from "@tanstack/react-start";
+import { samsMatchesInputSchema } from "@utils/sams-matches";
 import { z } from "zod";
 import { requireAdminMiddleware } from "../../middleware";
 import {
@@ -19,22 +20,15 @@ import {
   handleGetSamsTicker,
   handleListSamsClubs,
   handleListSamsTeams,
-  handlePeekSamsMatchesCache,
+  handleLoadSamsMatchesForSsr,
+  handleReadSamsMatchesCache,
   handlePeekSamsRankingsCache,
   handleTriggerSamsClubsSync,
   handleTriggerSamsTeamsSync,
 } from "./sams.server";
 
-const samsMatchesInputSchema = z
-  .object({
-    league: z.string().optional(),
-    season: z.string().optional(),
-    sportsclub: z.string().optional(),
-    team: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-    range: z.enum(["past", "future"]).optional(),
-  })
-  .optional();
+export type { SamsMatchesInput } from "@utils/sams-matches";
+export type { SamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
 
 const clubLogoInputSchema = z.union([
   z.object({ clubUuid: z.string().min(1), clubSlug: z.undefined().optional() }),
@@ -57,9 +51,14 @@ export const peekSamsRankingsCacheFn = createServerFn()
   .validator(z.object({ leagueUuids: z.array(z.string()) }))
   .handler(async ({ data }) => handlePeekSamsRankingsCache(data.leagueUuids));
 
-export const peekSamsMatchesCacheFn = createServerFn()
+export const readSamsMatchesCacheFn = createServerFn()
   .validator(samsMatchesInputSchema)
-  .handler(async ({ data }) => handlePeekSamsMatchesCache(data));
+  .handler(async ({ data }) => handleReadSamsMatchesCache(data));
+
+/** SSR loader helper — peek-only, returns hook options for useSamsMatches. */
+export const loadSamsMatchesForSsrFn = createServerFn()
+  .validator(samsMatchesInputSchema)
+  .handler(async ({ data }) => handleLoadSamsMatchesForSsr(data));
 
 export const listSamsClubsFn = createServerFn().handler(async () => handleListSamsClubs());
 
diff --git a/app/src/utils/sams-ssr.test.ts b/app/src/utils/sams-ssr.test.ts
new file mode 100644
index 000000000..d90f19da1
--- /dev/null
+++ b/app/src/utils/sams-ssr.test.ts
@@ -0,0 +1,29 @@
+import dayjs from "dayjs";
+import { describe, expect, it } from "vite-plus/test";
+import { buildSamsMatchesHookOptions } from "@webapp/utils/sams-ssr";
+
+describe("buildSamsMatchesHookOptions", () => {
+  it("bundles peek cache data for useSamsMatches", () => {
+    const cached = {
+      matches: [],
+      timestamp: "2026-07-21T08:00:00.000Z",
+    };
+
+    const options = buildSamsMatchesHookOptions({ range: "future", limit: 5 }, cached);
+
+    expect(options).toEqual({
+      range: "future",
+      limit: 5,
+      initialData: cached,
+      initialDataUpdatedAt: dayjs(cached.timestamp).valueOf(),
+    });
+  });
+
+  it("omits initialData when cache is empty", () => {
+    expect(buildSamsMatchesHookOptions({ range: "past" }, null)).toEqual({
+      range: "past",
+      initialData: undefined,
+      initialDataUpdatedAt: undefined,
+    });
+  });
+});
diff --git a/app/src/utils/sams-ssr.ts b/app/src/utils/sams-ssr.ts
new file mode 100644
index 000000000..15e03df04
--- /dev/null
+++ b/app/src/utils/sams-ssr.ts
@@ -0,0 +1,22 @@
+import dayjs from "dayjs";
+import type { LeagueMatchesResponse } from "@/lambda/sams/types";
+import type { SamsMatchesInput } from "@utils/sams-matches";
+
+export type { SamsMatchesInput };
+
+export type SamsMatchesHookOptions = SamsMatchesInput & {
+  initialData?: LeagueMatchesResponse;
+  initialDataUpdatedAt?: number;
+};
+
+/** Bundles peek cache data for useSamsMatches — client-safe, no server imports. */
+export function buildSamsMatchesHookOptions(
+  input: SamsMatchesInput,
+  cached: LeagueMatchesResponse | null | undefined,
+): SamsMatchesHookOptions {
+  return {
+    ...input,
+    initialData: cached ?? undefined,
+    initialDataUpdatedAt: cached?.timestamp ? dayjs(cached.timestamp).valueOf() : undefined,
+  };
+}
diff --git a/docs/adr/0001-sams-match-loading.md b/docs/adr/0001-sams-match-loading.md
index c326d504f..81b0c11eb 100644
--- a/docs/adr/0001-sams-match-loading.md
+++ b/docs/adr/0001-sams-match-loading.md
@@ -6,7 +6,7 @@ CloudWatch duration alarms on the webapp Lambda after the new season started.
 
 **Decision:** Load matches scoped to configured clubs, prefer the synced season from
 DynamoDB on cache miss, apply `past`/`future` filtering in application code after fetch,
-and use cache-peek loaders (`peekSamsMatchesCacheFn`) for SSR so navigation never blocks
+and use cache-peek loaders (`loadSamsMatchesForSsrFn`) for SSR so navigation never blocks
 on a live SAMS API call.
 
 ## Club filter
@@ -27,6 +27,9 @@ Season scoping is best-effort and deferred to the cache-miss path:
 
 1. Try the DynamoDB cache entry without a season key (backward-compatible with older cache).
 2. On miss, read `seasonUuid` from synced teams in DynamoDB (`getAllSamsTeams()`).
+   When teams disagree, use the season UUID held by the **majority** of synced teams;
+   on a tie, prefer the **most recently updated** team's season. Log a warning when
+   multiple distinct season UUIDs are present.
 3. If found, retry cache and API calls with `for-season=<uuid>`.
 4. If season resolution fails (missing table, sync not run, dev environment), fall back
    to **all seasons** for the configured clubs.
@@ -53,15 +56,19 @@ are fetched first.
 Route loaders must not call `getSamsMatchesFn` directly. That function may hit the SAMS
 API on cache miss and block navigation for several seconds.
 
-| Route                 | Loader                                             | Client refresh                                   |
-| --------------------- | -------------------------------------------------- | ------------------------------------------------ |
-| `/termine`            | `peekSamsMatchesCacheFn({ range: "future" })`      | `useSamsMatches({ range: "future" })`            |
-| `/tabelle`            | `peekSamsMatchesCacheFn({ range: "past", limit })` | `useSamsMatches` with `initialData`              |
-| `/teams/$slug`        | `peekSamsMatchesCacheFn({ team })`                 | `useSamsMatches({ team })`                       |
-| Homepage (Heimspiele) | none                                               | `useSamsMatches({ range: "future", limit: 50 })` |
+| Route                 | Loader                                              | Client refresh                                   |
+| --------------------- | --------------------------------------------------- | ------------------------------------------------ |
+| `/termine`            | `loadSamsMatchesForSsrFn({ range: "future" })`      | `useSamsMatches(hookOptions)`                    |
+| `/tabelle`            | `loadSamsMatchesForSsrFn({ range: "past", limit })` | `useSamsMatches(hookOptions)`                    |
+| `/teams/$slug`        | `loadSamsMatchesForSsrFn({ team })`                 | `useSamsMatches(hookOptions)`                    |
+| Homepage (Heimspiele) | none                                                | `useSamsMatches({ range: "future", limit: 50 })` |
+
+Loaders receive `hookOptions` from the server function and pass them to
+`useSamsMatches`. Do not call `getSamsMatchesFn` in loaders.
 
 React Query passes cached loader data as `initialData` and refetches in the background
-when stale.
+when stale. `useSamsMatches` uses a **5 minute** `staleTime`, aligned with the DynamoDB
+match cache TTL.
 
 ## Per-page behaviour
 
diff --git a/e2e/sams-smoke.spec.ts b/e2e/sams-smoke.spec.ts
new file mode 100644
index 000000000..97e271a1e
--- /dev/null
+++ b/e2e/sams-smoke.spec.ts
@@ -0,0 +1,67 @@
+import { expect, test } from "@playwright/test";
+
+/**
+ * SAMS route smokes — tolerant of empty DynamoDB / missing clubs & teams sync.
+ * Asserts HTTP 200 and a settled UI state (data, empty, or graceful error), never a crash.
+ *
+ * Routes whose loaders require DynamoDB are skipped when AWS_REGION is unset
+ * (Playwright's default `vp dev` webServer has no AWS credentials).
+ * Point WEBAPP_URL at a `vpr`-started server (or set AWS_REGION) to run the full suite.
+ */
+const hasAws = Boolean(process.env.AWS_REGION);
+
+test.describe("sams smoke", () => {
+  test("/termine renders and match section settles", async ({ page }) => {
+    const response = await page.goto("/termine", { waitUntil: "domcontentloaded" });
+
+    expect(response?.ok()).toBeTruthy();
+    await expect(page.getByRole("heading", { name: "Termine" })).toBeVisible();
+
+    await expect(
+      page.getByText(/Keine Ligaspiele|Ligaspiele|Fehler beim Laden der SBVV Ligaspiele/i),
+    ).toBeVisible({ timeout: 20_000 });
+  });
+
+  test("homepage heimspiele section mounts without error", async ({ page }) => {
+    const response = await page.goto("/", { waitUntil: "domcontentloaded" });
+
+    expect(response?.ok()).toBeTruthy();
+    await expect(page.getByText(/Willkommen beim/i).first()).toBeVisible();
+    // Section always mounts; empty copy appears after SAMS teams resolve (may be empty pre-sync).
+    await expect(page.locator("#heimspiele")).toBeAttached();
+  });
+
+  test.describe("requires DynamoDB", () => {
+    test.skip(!hasAws, "Requires AWS_REGION (use WEBAPP_URL against a vpr-started server)");
+
+    test("/tabelle renders and settles", async ({ page }) => {
+      const response = await page.goto("/tabelle", { waitUntil: "domcontentloaded" });
+
+      expect(response?.ok()).toBeTruthy();
+      await expect(page.getByRole("heading", { name: "Tabelle" })).toBeVisible();
+
+      await expect(
+        page.getByText(/Keine Daten gefunden|Unsere letzten|Fehler beim Laden der letzten Spiele/i),
+      ).toBeVisible({ timeout: 20_000 });
+    });
+
+    test("/teams renders the team index", async ({ page }) => {
+      const response = await page.goto("/teams", { waitUntil: "domcontentloaded" });
+
+      expect(response?.ok()).toBeTruthy();
+      await expect(page.getByRole("heading", { name: "Mannschaften" })).toBeVisible();
+      await expect(page.getByText(/Zurzeit umfasst unser Verein/i)).toBeVisible();
+    });
+
+    test("unknown team slug shows not-found UI", async ({ page }) => {
+      const response = await page.goto("/teams/e2e-nonexistent-team-slug", {
+        waitUntil: "domcontentloaded",
+      });
+
+      expect(response?.ok()).toBeTruthy();
+      await expect(page.getByRole("heading", { name: "Mannschaft nicht gefunden" })).toBeVisible({
+        timeout: 15_000,
+      });
+    });
+  });
+});
diff --git a/lambda/AGENTS.md b/lambda/AGENTS.md
index 5b09155a5..de96ba1f8 100644
--- a/lambda/AGENTS.md
+++ b/lambda/AGENTS.md
@@ -4,14 +4,15 @@ This file provides instructions specific to the `lambda/` directory, which conta
 
 ## Structure
 
-- `lambda/sams/` — Lambdas that sync and serve SAMS sports data (clubs, teams, rankings, matches, seasons, associations)
+- `lambda/sams/` — Lambdas that sync SAMS sports data (clubs sync, teams sync) and shared types
 - `lambda/content/` — Lambdas for content management (ICS calendar, image processing, S3 cleanup, sitemap)
 - `lambda/social/` — Lambdas for social media integrations (Instagram, Mastodon)
 - `lambda/utils/` — Shared Lambda utilities (e.g., Sentry error reporting)
 
 ## Key files to reference
 
-- `lambda/sams/sams-clubs.ts` — example of a typical SAMS sync Lambda
+- `lambda/sams/sams-clubs-sync.ts` — clubs sync Lambda (scheduled + admin trigger)
+- `lambda/sams/sams-teams-sync.ts` — teams sync Lambda (thin adapter over `lib/sams/teams-sync-service.ts`)
 - `lambda/content/handler.ts` — content Lambda handler
 - `lambda/social/mastodon-share.ts` — social media Lambda example
 - Generated SAMS API client: `codegen/sams/generated/` (do not edit generated files manually; run `vpr sams:codegen` to regenerate)
@@ -19,7 +20,7 @@ This file provides instructions specific to the `lambda/` directory, which conta
 ## Lambda conventions
 
 - Each Lambda file exports a single handler function.
-- Unit tests live alongside the Lambda file (e.g., `sams-clubs.test.ts` next to `sams-clubs.ts`).
+- Unit tests live alongside the Lambda file (e.g., `sams-clubs.test.ts` next to `sams-clubs-sync.ts`).
 - Use `aws-sdk-client-mock` in tests wherever AWS SDK calls are present.
 - Use the Sentry utility (`lambda/utils/sentry.ts`) for error reporting.
 - The SAMS API client is generated from `codegen/sams/swagger.json` — use it via `codegen/sams/generated/`.
diff --git a/lambda/sams/sams-associations.ts b/lambda/sams/sams-associations.ts
deleted file mode 100644
index 76b6e6682..000000000
--- a/lambda/sams/sams-associations.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import { type Association, getAssociationByUuid, getAssociations } from "@codegen/sams/generated/";
-import middy from "@middy/core";
-import type {
-  APIGatewayProxyEvent,
-  APIGatewayProxyHandler,
-  APIGatewayProxyResult,
-} from "aws-lambda";
-import { parseLambdaEnv } from "../utils/env";
-import { createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import { SamsAssociationsLambdaEnvironmentSchema } from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-associations");
-
-const env = parseLambdaEnv(SamsAssociationsLambdaEnvironmentSchema);
-const SAMS_API_KEY = env.SAMS_API_KEY;
-
-const lambdaHandler: APIGatewayProxyHandler = async (
-  event: APIGatewayProxyEvent,
-): Promise<APIGatewayProxyResult> => {
-  logger.appendKeys({ path: event.path });
-  logger.info("Getting SAMS associations", { pathParameters: event.pathParameters });
-  try {
-    if (!SAMS_API_KEY) {
-      console.error("SAMS API key not configured");
-      return {
-        statusCode: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "Server configuration error." }),
-      };
-    }
-
-    const { uuid } = event.pathParameters || {};
-    const { name } = event.queryStringParameters || {};
-
-    // Check if we're looking for a specific association by UUID
-    if (uuid) {
-      console.log(`🔍 Fetching association by UUID: ${uuid}`);
-      const { data, error, response } = await getAssociationByUuid({
-        path: { uuid },
-        headers: {
-          "X-API-Key": SAMS_API_KEY,
-        },
-      });
-      if (error) {
-        return {
-          statusCode: response?.status ?? 500,
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            error: `Error fetching association with UUID: ${uuid}`,
-            details: error,
-          }),
-        };
-      }
-      if (data) {
-        return {
-          statusCode: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "public, max-age=86400",
-          },
-          body: JSON.stringify({
-            association: data,
-            timestamp: new Date().toISOString(),
-          }),
-        };
-      }
-
-      return {
-        statusCode: 404,
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ error: "Association not found" }),
-      };
-    }
-
-    // Check if we're looking for a specific association by name
-    const allAssociations: Association[] = [];
-    let currentPage = 0;
-    let hasMorePages = true;
-    while (hasMorePages) {
-      const { data, error, response } = await getAssociations({
-        query: { page: currentPage, size: 100 },
-        headers: {
-          "X-API-Key": SAMS_API_KEY,
-        },
-      });
-
-      if (error) {
-        return {
-          statusCode: response?.status ?? 500,
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            error: `Error fetching associations page ${currentPage}`,
-            details: error,
-          }),
-        };
-      }
-
-      if (data.content) {
-        allAssociations.push(...data.content);
-        currentPage++;
-      }
-
-      if (data.last === true) {
-        hasMorePages = false;
-      }
-    }
-
-    // If looking for a specific association by name
-    if (name) {
-      const desiredAssociation = allAssociations.find(
-        (a) => a.name?.toLowerCase() === name.toLowerCase(),
-      );
-
-      if (!desiredAssociation) {
-        return {
-          statusCode: 404,
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            error: `Association with name '${name}' not found`,
-          }),
-        };
-      }
-
-      return {
-        statusCode: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=86400",
-        },
-        body: JSON.stringify({
-          association: desiredAssociation,
-          timestamp: new Date().toISOString(),
-        }),
-      };
-    }
-
-    // Return all associations
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=86400",
-      },
-      body: JSON.stringify({
-        associations: allAssociations,
-        total: allAssociations.length,
-        timestamp: new Date().toISOString(),
-      }),
-    };
-  } catch (error) {
-    console.error("Error fetching associations:", error);
-
-    return {
-      statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        error: "Failed to fetch associations",
-        message: error instanceof Error ? error.message : "Unknown error",
-        timestamp: new Date().toISOString(),
-      }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lambda/sams/sams-clubs.ts b/lambda/sams/sams-clubs.ts
deleted file mode 100644
index 8e031be2f..000000000
--- a/lambda/sams/sams-clubs.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import middy from "@middy/core";
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
-import { createSamsDb } from "@/lib/db/electrodb-client";
-import { slugify } from "@/utils/slugify";
-import { parseLambdaEnv } from "../utils/env";
-import { createDynamoDocClient, createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import { ClubResponseSchema, ClubsResponseSchema, SamsClubsLambdaEnvironmentSchema } from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-clubs");
-const docClient = createDynamoDocClient(tracer);
-
-const env = parseLambdaEnv(SamsClubsLambdaEnvironmentSchema);
-const TABLE_NAME = env.SAMS_TABLE_NAME;
-const samsEntities = createSamsDb(docClient, TABLE_NAME);
-
-const lambdaHandler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
-  logger.appendKeys({ path: event.path });
-  logger.info("📋 Querying clubs from DynamoDB", { pathParameters: event.pathParameters });
-
-  const { uuid } = event.pathParameters || {};
-  const { name } = event.queryStringParameters || {};
-
-  try {
-    // Check if this is a request for a specific club by UUID
-    if (uuid) {
-      // Get specific club by UUID (primary key lookup)
-      console.log(`🔍 Fetching club by UUID: ${uuid}`);
-
-      const result = await samsEntities.club.get({ sportsclubUuid: uuid }).go();
-
-      if (!result.data) {
-        return {
-          statusCode: 404,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "public, max-age=259200", // 3 days
-          },
-          body: JSON.stringify({ error: "Club not found" }),
-        };
-      }
-
-      return {
-        statusCode: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=259200",
-        },
-        body: JSON.stringify(ClubResponseSchema.parse(result.data)),
-      };
-    }
-
-    // Check if filtering by name query parameter
-    if (name) {
-      // Query by name using nameSlug GSI with prefix matching (case-insensitive)
-      const slugifiedName = slugify(name);
-      console.log(`🔍 Querying club by name prefix: ${name} (slug: ${slugifiedName})`);
-
-      const result = await samsEntities.club.query
-        .byType({ type: "club" })
-        .begins({ nameSlug: slugifiedName })
-        .go({ pages: "all" });
-
-      if (!result.data || result.data.length === 0) {
-        return {
-          statusCode: 404,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "public, max-age=259200", // 3 days
-          },
-          body: JSON.stringify({ error: "Club not found" }),
-        };
-      }
-
-      // Return first match if exact match, otherwise all prefix matches
-      const exactMatch = result.data.find((item) => item.nameSlug === slugifiedName);
-      if (exactMatch) {
-        return {
-          statusCode: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "public, max-age=259200",
-          },
-          body: JSON.stringify(ClubResponseSchema.parse(exactMatch)),
-        };
-      }
-
-      // Return all prefix matches
-      return {
-        statusCode: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=259200",
-        },
-        body: JSON.stringify(
-          ClubsResponseSchema.parse({
-            clubs: result.data.map((item) => ClubResponseSchema.parse(item)),
-            count: result.data.length,
-          }),
-        ),
-      };
-    }
-
-    // No filters - return all clubs (scan)
-    console.log("📊 Fetching all clubs");
-
-    const result = await samsEntities.club.query.byType({ type: "club" }).go({ pages: "all" });
-
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=259200",
-      },
-      body: JSON.stringify(
-        ClubsResponseSchema.parse({
-          clubs: result.data.map((item) => ClubResponseSchema.parse(item)),
-          count: result.data.length,
-        }),
-      ),
-    };
-  } catch (error) {
-    logger.error("🚨 Error querying clubs:", { error });
-    return {
-      statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        error: "Internal server error",
-        message: error instanceof Error ? error.message : "Unknown error",
-      }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lambda/sams/sams-league-matches.ts b/lambda/sams/sams-league-matches.ts
deleted file mode 100644
index 280e22132..000000000
--- a/lambda/sams/sams-league-matches.ts
+++ /dev/null
@@ -1,254 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import { getAllLeagueMatches, type LeagueMatchDto } from "@codegen/sams/generated";
-import middy from "@middy/core";
-import type { APIGatewayProxyEvent, APIGatewayProxyHandler } from "aws-lambda";
-import dayjs from "dayjs";
-import { createSamsDb } from "@/lib/db/electrodb-client";
-import {
-  dedupeSamsMatchesByUuid,
-  resolveConfiguredSamsSportsclubUuids,
-  SAMS_TARGET_CLUB_SLUGS,
-  shouldResolveDefaultSamsSportsclubs,
-} from "../../utils/sams";
-import { parseLambdaEnv } from "../utils/env";
-import { createDynamoDocClient, createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import {
-  LeagueMatchesResponseSchema,
-  SamsLeagueMatchesLambdaEnvironmentSchema,
-  SeasonsResponseSchema,
-} from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-league-matches");
-const docClient = createDynamoDocClient(tracer);
-
-const env = parseLambdaEnv(SamsLeagueMatchesLambdaEnvironmentSchema);
-const SAMS_API_KEY = env.SAMS_API_KEY;
-const TABLE_NAME = env.SAMS_TABLE_NAME;
-const samsEntities = createSamsDb(docClient, TABLE_NAME);
-
-async function resolveConfiguredSamsSportsclubUuidsFromStorage(): Promise<string[]> {
-  const clubResponse = await samsEntities.club.query.byType({ type: "club" }).go({ pages: "all" });
-  const missingClubSlugs = SAMS_TARGET_CLUB_SLUGS.filter(
-    (clubSlug) =>
-      !clubResponse.data.some((club) => club.nameSlug === clubSlug && !!club.sportsclubUuid),
-  );
-
-  if (missingClubSlugs.length > 0) {
-    logger.warn("Failed to resolve configured SAMS clubs", { missingClubSlugs });
-  }
-
-  return resolveConfiguredSamsSportsclubUuids(clubResponse.data);
-}
-
-async function fetchAllLeagueMatchesForSportsclubs({
-  league,
-  season,
-  team,
-  sportsclubUuids,
-}: {
-  league?: string;
-  season?: string;
-  team?: string;
-  sportsclubUuids: readonly string[];
-}): Promise<Omit<LeagueMatchDto, "_links">[]> {
-  const sportsclubFilters = sportsclubUuids.length > 0 ? sportsclubUuids : [undefined];
-  const allMatches: Omit<LeagueMatchDto, "_links">[] = [];
-
-  for (const sportsclubUuid of sportsclubFilters) {
-    const defaultQueryParams: Record<string, string> = {};
-    if (league) defaultQueryParams["for-league"] = league;
-    if (season) defaultQueryParams["for-season"] = season;
-    if (sportsclubUuid) defaultQueryParams["for-sportsclub"] = sportsclubUuid;
-    if (team) defaultQueryParams["for-team"] = team;
-
-    let currentPage = 0;
-    let hasMorePages = true;
-    while (hasMorePages) {
-      const { data } = await getAllLeagueMatches({
-        query: {
-          ...defaultQueryParams,
-          page: currentPage,
-          size: 100,
-        },
-        headers: {
-          "X-API-Key": SAMS_API_KEY,
-        },
-      });
-
-      if (!data) {
-        if (currentPage === 0) {
-          console.warn("SAMS API returned no data on first page", {
-            page: currentPage,
-            sportsclubUuid,
-            league,
-            season,
-            team,
-          });
-          Sentry.metrics.count("sams.league_matches.empty_response", 1, {
-            attributes: {
-              page: String(currentPage),
-              sportsclub_uuid: sportsclubUuid ?? "",
-              league: league ?? "",
-              season: season ?? "",
-              team: team ?? "",
-            },
-          });
-        }
-        break;
-      }
-
-      if (data.content) {
-        const matches = data.content.map(({ _links, ...match }) => match);
-        allMatches.push(...matches);
-        currentPage++;
-      }
-
-      if (data.last === true) {
-        hasMorePages = false;
-      }
-    }
-  }
-
-  return dedupeSamsMatchesByUuid(allMatches);
-}
-
-const lambdaHandler: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
-  logger.appendKeys({ path: event.path });
-  logger.info("Getting SAMS league matches", { pathParameters: event.pathParameters });
-  try {
-    if (!SAMS_API_KEY) {
-      console.error("SAMS API key not configured");
-      return {
-        statusCode: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "Server configuration error." }),
-      };
-    }
-
-    // Parse query parameters
-    const queryParams = event.queryStringParameters || {};
-    let { league, season, sportsclub, team, limit, range } = queryParams;
-
-    const shouldUseDefaultSportsclubs = shouldResolveDefaultSamsSportsclubs({
-      league,
-      sportsclub,
-      team,
-    });
-    const defaultSportsclubUuids = shouldUseDefaultSportsclubs
-      ? await resolveConfiguredSamsSportsclubUuidsFromStorage()
-      : [];
-    if (shouldUseDefaultSportsclubs && defaultSportsclubUuids.length === 0) {
-      logger.warn("No configured SAMS sportsclub UUIDs resolved; returning empty matches", {
-        league,
-        season,
-      });
-      return {
-        statusCode: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=300",
-        },
-        body: JSON.stringify(
-          LeagueMatchesResponseSchema.parse({
-            matches: [],
-            timestamp: new Date().toISOString(),
-          }),
-        ),
-      };
-    }
-    const effectiveSportsclubUuids = sportsclub ? [sportsclub] : defaultSportsclubUuids;
-
-    // Get current season if not specified
-    if (!season) {
-      try {
-        const seasonsResponse = await fetch(`https://${event.requestContext.domainName}/seasons`);
-        if (seasonsResponse.ok) {
-          const seasonsData = await seasonsResponse.json();
-          season = SeasonsResponseSchema.parse(seasonsData).current.uuid;
-        }
-      } catch (error) {
-        console.warn("Failed to fetch current season, proceeding without default:", error);
-        return {
-          statusCode: 400,
-          headers: {
-            "Content-Type": "application/json",
-            "Cache-Control": "no-cache",
-          },
-          body: JSON.stringify({
-            error: "Unable to determine season automatically. Please specify a season.",
-          }),
-        };
-      }
-    }
-
-    const allMatches = await fetchAllLeagueMatchesForSportsclubs({
-      league,
-      season,
-      team,
-      sportsclubUuids: effectiveSportsclubUuids,
-    });
-
-    // Filter matches based on range
-    let filteredMatches = allMatches;
-    if (range === "future") {
-      // Filter by matches without a winner (not yet played)
-      filteredMatches = allMatches.filter((m) => !m.results?.winner);
-    } else if (range === "past") {
-      // Filter by matches with a winner (already played)
-      filteredMatches = allMatches.filter((m) => !!m.results?.winner);
-    } // Sort matches by date
-    if (range === "future") {
-      filteredMatches.sort((a, b) => {
-        if (!a.date) return 1;
-        if (!b.date) return -1;
-        return dayjs(a.date).isBefore(dayjs(b.date)) ? -1 : 1;
-      });
-    } else if (range === "past") {
-      filteredMatches.sort((a, b) => {
-        if (!a.date) return 1;
-        if (!b.date) return -1;
-        return dayjs(a.date).isAfter(dayjs(b.date)) ? -1 : 1;
-      });
-    } // Apply limit if specified
-    if (limit) {
-      const limitNum = parseInt(limit, 10);
-      if (!Number.isNaN(limitNum)) {
-        filteredMatches = filteredMatches.slice(0, limitNum);
-      }
-    }
-
-    const result = LeagueMatchesResponseSchema.parse({
-      matches: filteredMatches,
-      timestamp: new Date().toISOString(),
-    });
-
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=300",
-      },
-      body: JSON.stringify(result),
-    };
-  } catch (error) {
-    logger.error("Error fetching league matches:", { error });
-    Sentry.captureException(error);
-    return {
-      statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-cache",
-      },
-      body: JSON.stringify({ error: "Internal server error" }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lambda/sams/sams-rankings.ts b/lambda/sams/sams-rankings.ts
deleted file mode 100644
index 345313d14..000000000
--- a/lambda/sams/sams-rankings.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import { getLeagueByUuid, getRankingsForLeague, getSeasonByUuid } from "@codegen/sams/generated";
-import middy from "@middy/core";
-import type { APIGatewayProxyEvent, APIGatewayProxyHandler } from "aws-lambda";
-import { parseLambdaEnv } from "../utils/env";
-import { createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import { RankingResponseSchema, SamsRankingsLambdaEnvironmentSchema } from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-rankings");
-
-const env = parseLambdaEnv(SamsRankingsLambdaEnvironmentSchema);
-const SAMS_API_KEY = env.SAMS_API_KEY;
-
-const lambdaHandler: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
-  logger.appendKeys({ path: event.path });
-  logger.info("Getting SAMS rankings", { pathParameters: event.pathParameters });
-  try {
-    if (!SAMS_API_KEY) {
-      return {
-        statusCode: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "SAMS API key not configured" }),
-      };
-    }
-
-    const leagueUuid = event.pathParameters?.leagueUuid;
-    if (!leagueUuid) {
-      return {
-        statusCode: 400,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "League UUID is required" }),
-      };
-    }
-
-    const { data } = await getRankingsForLeague({
-      path: { uuid: leagueUuid },
-      query: { page: 0, size: 100 },
-      headers: {
-        "X-API-Key": SAMS_API_KEY,
-      },
-    });
-
-    if (!data?.content) {
-      return {
-        statusCode: 404,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=300",
-        },
-        body: JSON.stringify({ error: "No rankings found for this league" }),
-      };
-    }
-
-    let leagueName: string | undefined;
-    let seasonName: string | undefined;
-
-    const { data: leagueData } = await getLeagueByUuid({
-      path: { uuid: leagueUuid },
-      headers: {
-        "X-API-Key": SAMS_API_KEY,
-      },
-    });
-    if (leagueData?.name) leagueName = leagueData.name;
-
-    if (leagueData?.seasonUuid) {
-      const { data: seasonData } = await getSeasonByUuid({
-        path: { uuid: leagueData.seasonUuid },
-        headers: {
-          "X-API-Key": SAMS_API_KEY,
-        },
-      });
-      if (seasonData?.name) seasonName = seasonData.name;
-    }
-
-    const result = RankingResponseSchema.parse({
-      teams: data.content,
-      timestamp: new Date().toISOString(),
-      leagueUuid,
-      leagueName,
-      seasonName,
-    });
-
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=300",
-      },
-      body: JSON.stringify(result),
-    };
-  } catch (error) {
-    logger.error("Error fetching rankings:", { error });
-    return {
-      statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-cache",
-      },
-      body: JSON.stringify({ error: "Internal server error" }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lambda/sams/sams-seasons.ts b/lambda/sams/sams-seasons.ts
deleted file mode 100644
index 9d3756340..000000000
--- a/lambda/sams/sams-seasons.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import { getAllSeasons } from "@codegen/sams/generated";
-import middy from "@middy/core";
-import type { APIGatewayProxyEvent, APIGatewayProxyHandler } from "aws-lambda";
-import dayjs from "dayjs";
-import { parseLambdaEnv } from "../utils/env";
-import { createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import { SamsSeasonsLambdaEnvironmentSchema, SeasonsResponseSchema } from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-seasons");
-
-const env = parseLambdaEnv(SamsSeasonsLambdaEnvironmentSchema);
-const SAMS_API_KEY = env.SAMS_API_KEY;
-
-const lambdaHandler: APIGatewayProxyHandler = async (event: APIGatewayProxyEvent) => {
-  logger.appendKeys({ path: event.path });
-  logger.info("Getting SAMS seasons", { pathParameters: event.pathParameters });
-  try {
-    if (!SAMS_API_KEY) {
-      console.error("SAMS API key not configured");
-      return {
-        statusCode: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "Server configuration error." }),
-      };
-    }
-
-    const { data: seasons } = await getAllSeasons({
-      headers: {
-        "X-API-Key": SAMS_API_KEY,
-      },
-    });
-    if (!seasons || seasons.length === 0) {
-      return {
-        statusCode: 404,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=300",
-        },
-        body: JSON.stringify({ error: "No seasons found" }),
-      };
-    }
-
-    const currentSeason = seasons.find((s) => s.currentSeason);
-
-    if (!currentSeason) {
-      return {
-        statusCode: 404,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=300",
-        },
-        body: JSON.stringify({ error: "No current season found" }),
-      };
-    }
-    const nextSeason = seasons.find((s) =>
-      dayjs(s.startDate).subtract(1, "day").isSame(currentSeason.endDate),
-    );
-    const previousSeason = seasons.find((s) =>
-      dayjs(s.endDate).add(1, "day").isSame(currentSeason.startDate),
-    );
-
-    const result = SeasonsResponseSchema.parse({
-      current: currentSeason,
-      next: nextSeason,
-      previous: previousSeason,
-    });
-
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=43200",
-      },
-      body: JSON.stringify(result),
-    };
-  } catch (error) {
-    console.error("Error fetching seasons:", error);
-    return {
-      statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "no-cache",
-      },
-      body: JSON.stringify({ error: "Internal server error" }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lambda/sams/sams-teams-sync.ts b/lambda/sams/sams-teams-sync.ts
index d256b2ea9..fa86fae2d 100644
--- a/lambda/sams/sams-teams-sync.ts
+++ b/lambda/sams/sams-teams-sync.ts
@@ -1,22 +1,12 @@
-import { createHash } from "node:crypto";
 import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
 import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import {
-  getAllLeagueHierarchies,
-  getAllLeagues,
-  getAllSeasons,
-  getTeamRosterByTeamUuid,
-  getTeamsForLeague,
-} from "@codegen/sams/generated";
 import middy from "@middy/core";
 import type { APIGatewayProxyHandler } from "aws-lambda";
 import { createSamsDb } from "@/lib/db/electrodb-client";
-import { slugify } from "../../utils/slugify";
-import { resolveConfiguredSamsSportsclubUuids, SAMS_TARGET_CLUB_SLUGS } from "../../utils/sams";
+import { runSamsTeamsSync } from "@/lib/sams/teams-sync-service";
 import { parseLambdaEnv } from "../utils/env";
 import { createDynamoDocClient, createLambdaResources } from "../utils/resources";
 import { Sentry } from "../utils/sentry";
-import type { RosterOfficial, RosterPlayer } from "./types";
 import { SamsTeamsSyncLambdaEnvironmentSchema } from "./types";
 
 const { logger, tracer } = createLambdaResources("sams-teams-sync");
@@ -26,365 +16,55 @@ const env = parseLambdaEnv(SamsTeamsSyncLambdaEnvironmentSchema);
 const TABLE_NAME = env.SAMS_TABLE_NAME;
 const samsEntities = createSamsDb(docClient, TABLE_NAME);
 
-type SyncedTeamItem = {
-  uuid: string;
-  type: "team";
-  name: string;
-  nameSlug: string;
-  sportsclubUuid: string;
-  associationUuid: string;
-  leagueUuid: string;
-  leagueName: string;
-  leagueHierarchyLevel?: number;
-  seasonUuid: string;
-  seasonName: string;
-  updatedAt: string;
-  ttl: number;
-};
-
-type SyncedRosterItem = {
-  teamUuid: string;
-  type: "roster";
-  players: RosterPlayer[];
-  officials: RosterOfficial[];
-  updatedAt: string;
-  ttl: number;
-};
-
-function pseudoRosterUuid(
-  teamUuid: string,
-  kind: "player" | "official",
-  ...parts: (string | number | undefined)[]
-): string {
-  const input = [teamUuid, kind, ...parts.map((part) => String(part ?? ""))].join("|");
-  const hex = createHash("sha256").update(input).digest("hex").slice(0, 32);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-
-function mapRosterPlayers(
-  teamUuid: string,
-  players: Array<{
-    uuid?: string;
-    name?: string | null;
-    jerseyNumber?: number | null;
-    position?: string | null;
-    portraitImageLink?: string | null;
-  }> = [],
-): RosterPlayer[] {
-  return players
-    .filter((p): p is typeof p & { name: string } => !!p.name?.trim())
-    .map((p) => ({
-      // The SAMS API sometimes omits uuid; derive a deterministic pseudo uuid from stable fields
-      uuid: p.uuid ?? pseudoRosterUuid(teamUuid, "player", p.name, p.jerseyNumber ?? undefined),
-      name: p.name,
-      ...(p.jerseyNumber != null ? { jerseyNumber: p.jerseyNumber } : {}),
-      ...(p.position ? { position: p.position } : {}),
-      ...(p.portraitImageLink ? { portraitImageLink: p.portraitImageLink } : {}),
-    }));
-}
-
-function mapRosterOfficials(
-  teamUuid: string,
-  officials: Array<{
-    uuid?: string;
-    name?: string | null;
-    role?: string | null;
-  }> = [],
-): RosterOfficial[] {
-  return officials
-    .filter((o): o is typeof o & { name: string } => !!o.name?.trim())
-    .map((o) => ({
-      // The SAMS API sometimes omits uuid; derive a deterministic pseudo uuid from stable fields
-      uuid: o.uuid ?? pseudoRosterUuid(teamUuid, "official", o.name, o.role ?? undefined),
-      name: o.name,
-      ...(o.role ? { role: o.role } : {}),
-    }));
-}
-
-async function resolveConfiguredSamsClubsFromStorage() {
-  const clubResponse = await samsEntities.club.query.byType({ type: "club" }).go({ pages: "all" });
-  const missingClubSlugs = SAMS_TARGET_CLUB_SLUGS.filter(
-    (clubSlug) =>
-      !clubResponse.data.some((club) => club.nameSlug === clubSlug && !!club.sportsclubUuid),
-  );
-
-  if (missingClubSlugs.length > 0) {
-    logger.warn("Failed to resolve configured SAMS clubs", { missingClubSlugs });
-  }
-
-  const sportsclubUuids = new Set(resolveConfiguredSamsSportsclubUuids(clubResponse.data));
-  return clubResponse.data.filter(
-    (club) => club.sportsclubUuid && sportsclubUuids.has(club.sportsclubUuid),
-  );
-}
-
 const lambdaHandler: APIGatewayProxyHandler = async () => {
   logger.info("Starting SAMS teams sync...");
   Sentry.addBreadcrumb({ category: "sync", message: "Starting SAMS teams sync", level: "info" });
-  try {
-    // Step 1: Get configured SAMS clubs from DynamoDB
-    console.log("Fetching configured SAMS club data...");
-    const clubs = await resolveConfiguredSamsClubsFromStorage();
-    if (clubs.length === 0) {
-      throw new Error("No configured SAMS clubs found in DynamoDB");
-    }
-
-    const sportsclubUuids = new Set(clubs.map((club) => club.sportsclubUuid));
-    const associationUuids = [
-      ...new Set(clubs.flatMap((club) => (club.associationUuid ? [club.associationUuid] : []))),
-    ];
-
-    if (associationUuids.length === 0) {
-      throw new Error("Configured SAMS clubs have no associationUuid — cannot fetch leagues");
-    }
 
-    console.log(
-      `Found configured clubs: ${clubs.map((club) => `${club.name} (${club.sportsclubUuid})`).join(", ")}`,
-    );
-    Sentry.addBreadcrumb({
-      category: "sync",
-      message: "Found configured SAMS clubs",
-      level: "info",
-      data: {
-        clubs: clubs.map((club) => ({ name: club.name, sportsclubUuid: club.sportsclubUuid })),
+  try {
+    const result = await runSamsTeamsSync({
+      samsEntities,
+      logger: {
+        info: (message, meta) => logger.info(message, meta ?? {}),
+        warn: (message, meta) => logger.warn(message, meta ?? {}),
       },
-    });
-
-    // Step 2: Get current season
-    console.log("Fetching current season...");
-    const { data: seasons } = await getAllSeasons({});
-
-    const currentSeason = seasons?.find((s) => s.currentSeason);
-    if (!currentSeason) {
-      throw new Error("Current season not found");
-    }
-    if (!currentSeason.uuid || !currentSeason.name) {
-      throw new Error("Current season is missing uuid or name");
-    }
-    console.log(`Current season: ${currentSeason.name} (${currentSeason.uuid})`);
-
-    // Step 3: Get all leagues for the association filtered by current season.
-    // build a hierarchy level map so we can store the level on each team.
-    console.log(`Fetching leagues for associations ${associationUuids.join(", ")}...`);
-    const allLeagues = [];
-    let leaguePage = 0;
-    let hasMoreLeagues = true;
-
-    // Build hierarchy level map: hierarchyUuid → level number
-    const hierarchyLevelByUuid = new Map<string, number>();
-    for (const associationUuid of associationUuids) {
-      let hierarchyPage = 0;
-      let hasMoreHierarchies = true;
-      while (hasMoreHierarchies) {
-        const { data: hierarchyData } = await getAllLeagueHierarchies({
-          query: {
-            association: associationUuid,
-            "for-season": currentSeason.uuid,
-            page: hierarchyPage,
-            size: 100,
-          },
+      onTeamsFound: (teamsFound, teamsBySportsclubUuid) => {
+        console.log(`Found ${teamsFound} teams for configured SAMS clubs`);
+        Sentry.addBreadcrumb({
+          category: "sync",
+          message: `Found ${teamsFound} teams for configured SAMS clubs`,
+          level: "info",
+          data: { teamsFound, teamsBySportsclubUuid },
         });
-        for (const hierarchy of hierarchyData?.content ?? []) {
-          if (hierarchy.uuid && hierarchy.level !== undefined) {
-            hierarchyLevelByUuid.set(hierarchy.uuid, hierarchy.level);
-          }
-        }
-        hasMoreHierarchies = hierarchyData?.last !== true;
-        hierarchyPage++;
-      }
-
-      leaguePage = 0;
-      hasMoreLeagues = true;
-      while (hasMoreLeagues) {
-        const { data: leagueData } = await getAllLeagues({
-          query: {
-            association: associationUuid,
-            page: leaguePage,
-            size: 100,
-          },
-        });
-
-        if (leagueData?.content) {
-          const currentSeasonLeagues = leagueData.content.filter(
-            (league) => league.seasonUuid === currentSeason.uuid,
-          );
-          allLeagues.push(...currentSeasonLeagues);
-          leaguePage++;
-        }
-
-        if (leagueData?.last === true) {
-          hasMoreLeagues = false;
-        }
-
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-    }
-
-    console.log(`Found ${allLeagues.length} leagues for current season`);
-    Sentry.addBreadcrumb({
-      category: "sync",
-      message: `Found ${allLeagues.length} leagues for current season`,
-      level: "info",
-      data: { leaguesFound: allLeagues.length },
-    });
-    Sentry.setMeasurement("sams_teams_sync.leagues_found", allLeagues.length, "none");
-
-    // Step 4: Get teams from each league
-    const allTeams: SyncedTeamItem[] = [];
-    for (const league of allLeagues) {
-      if (!league.uuid || !league.name) continue;
-
-      console.log(`Fetching teams for league: ${league.name}...`);
-      let teamPage = 0;
-      let hasMoreTeams = true;
-
-      while (hasMoreTeams) {
-        const { data: teamData } = await getTeamsForLeague({
-          path: { uuid: league.uuid },
-          query: { page: teamPage, size: 100 },
-        });
-
-        if (teamData?.content) {
-          // Filter: only our club's teams, no sub-teams (masterTeamUuid)
-          const ourTeams: SyncedTeamItem[] = teamData.content
-            .filter((t) => !t.masterTeamUuid)
-            .filter((t) => !!t.sportsclubUuid && sportsclubUuids.has(t.sportsclubUuid))
-            .filter((t) => !!t.uuid && !!t.name && !!t.sportsclubUuid && !!t.associationUuid)
-            .map((t) => {
-              const leagueHierarchyLevel = league.leagueHierarchyUuid
-                ? hierarchyLevelByUuid.get(league.leagueHierarchyUuid)
-                : undefined;
-
-              return {
-                uuid: t.uuid as string,
-                type: "team" as const,
-                name: t.name as string,
-                nameSlug: slugify(t.name || ""),
-                sportsclubUuid: t.sportsclubUuid as string,
-                associationUuid: t.associationUuid as string,
-                leagueUuid: league.uuid as string,
-                leagueName: league.name as string,
-                ...(leagueHierarchyLevel !== undefined ? { leagueHierarchyLevel } : {}),
-                seasonUuid: currentSeason.uuid as string,
-                seasonName: currentSeason.name as string,
-                updatedAt: new Date().toISOString(),
-                ttl: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365,
-              };
-            });
-
-          allTeams.push(...ourTeams);
-          teamPage++;
-        }
-        if (teamData?.last === true) {
-          hasMoreTeams = false;
-        }
-
-        await new Promise((resolve) => setTimeout(resolve, 500)); // Rate limiting
-      }
-    }
-
-    const teamsBySportsclubUuid = Object.fromEntries(
-      [...sportsclubUuids].map((sportsclubUuid) => [
-        sportsclubUuid,
-        allTeams.filter((team) => team.sportsclubUuid === sportsclubUuid).length,
-      ]),
-    );
-
-    console.log(`Found ${allTeams.length} teams for configured SAMS clubs`);
-    Sentry.addBreadcrumb({
-      category: "sync",
-      message: `Found ${allTeams.length} teams for configured SAMS clubs`,
-      level: "info",
-      data: { teamsFound: allTeams.length, teamsBySportsclubUuid },
-    });
-    Sentry.setMeasurement("sams_teams_sync.teams_found", allTeams.length, "none");
-
-    // Step 5: Store teams (and their rosters) in DynamoDB
-    let teamsProcessed = 0;
-    let rostersProcessed = 0;
-    let rostersFailed = 0;
-
-    for (const team of allTeams) {
-      await samsEntities.team.upsert(team).go();
-      teamsProcessed++;
-
-      try {
-        const { data: rosterData, error: rosterError } = await getTeamRosterByTeamUuid({
-          path: { uuid: team.uuid },
-        });
-        if (rosterError) {
-          throw rosterError;
-        }
-        if (rosterData) {
-          const rosterItem: SyncedRosterItem = {
-            teamUuid: team.uuid,
-            type: "roster",
-            players: mapRosterPlayers(team.uuid, rosterData.players),
-            officials: mapRosterOfficials(team.uuid, rosterData.officials),
-            updatedAt: new Date().toISOString(),
-            ttl: Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365,
-          };
-          await samsEntities.roster.upsert(rosterItem).go();
-          rostersProcessed++;
-        }
-      } catch (error) {
+        Sentry.setMeasurement("sams_teams_sync.teams_found", teamsFound, "none");
+      },
+      captureRosterError: (error, team) => {
         console.warn(`Failed to fetch roster for team ${team.name} (${team.uuid}):`, error);
         Sentry.captureException(error, {
           extra: { teamUuid: team.uuid, teamName: team.name },
         });
-        await samsEntities.roster
-          .delete({ teamUuid: team.uuid })
-          .go()
-          .catch((deleteError) => {
-            console.warn(`Failed to delete stale roster for team ${team.uuid}:`, deleteError);
-          });
-        rostersFailed++;
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 500)); // Rate limiting
-    }
-
-    // Step 6: Delete stale teams (not updated in this sync) and their rosters
-    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-    const existingResponse = await samsEntities.team.query
-      .byType({ type: "team" })
-      .go({ pages: "all" });
-    let teamsDeleted = 0;
-    for (const existingTeam of existingResponse.data) {
-      if (existingTeam.updatedAt < oneHourAgo) {
-        await samsEntities.team.delete({ uuid: existingTeam.uuid }).go();
-        await samsEntities.roster.delete({ teamUuid: existingTeam.uuid }).go();
-        console.log(`Deleted stale team: ${existingTeam.name}`);
-        teamsDeleted++;
-      }
-    }
-
-    const result = {
-      success: true,
-      teamsProcessed,
-      teamsDeleted,
-      rostersProcessed,
-      rostersFailed,
-      timestamp: new Date().toISOString(),
-    };
-
-    console.log("Teams sync completed:", result);
-    Sentry.setMeasurement("sams_teams_sync.teams_processed", teamsProcessed, "none");
-    Sentry.setMeasurement("sams_teams_sync.teams_deleted", teamsDeleted, "none");
-    Sentry.setMeasurement("sams_teams_sync.rosters_processed", rostersProcessed, "none");
-    Sentry.setMeasurement("sams_teams_sync.rosters_failed", rostersFailed, "none");
-    Sentry.addBreadcrumb({
-      category: "sync",
-      message: "Teams sync completed",
-      level: "info",
-      data: result,
+      },
+      onComplete: (syncResult) => {
+        console.log("Teams sync completed:", syncResult);
+        Sentry.setMeasurement("sams_teams_sync.teams_processed", syncResult.teamsProcessed, "none");
+        Sentry.setMeasurement("sams_teams_sync.teams_deleted", syncResult.teamsDeleted, "none");
+        Sentry.setMeasurement(
+          "sams_teams_sync.rosters_processed",
+          syncResult.rostersProcessed,
+          "none",
+        );
+        Sentry.setMeasurement("sams_teams_sync.rosters_failed", syncResult.rostersFailed, "none");
+        Sentry.addBreadcrumb({
+          category: "sync",
+          message: "Teams sync completed",
+          level: "info",
+          data: syncResult,
+        });
+      },
     });
 
     return {
       statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-      },
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify(result),
     };
   } catch (error) {
@@ -392,9 +72,7 @@ const lambdaHandler: APIGatewayProxyHandler = async () => {
     Sentry.captureException(error);
     return {
       statusCode: 500,
-      headers: {
-        "Content-Type": "application/json",
-      },
+      headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         error: "Internal server error",
         message: error instanceof Error ? error.message : "Unknown error",
diff --git a/lambda/sams/sams-teams.ts b/lambda/sams/sams-teams.ts
deleted file mode 100644
index 16960415d..000000000
--- a/lambda/sams/sams-teams.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-import { getTeamByUuid } from "@codegen/sams/generated";
-import middy from "@middy/core";
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
-import { createSamsDb } from "@/lib/db/electrodb-client";
-import { slugify } from "@/utils/slugify";
-import { parseLambdaEnv } from "../utils/env";
-import { createDynamoDocClient, createLambdaResources } from "../utils/resources";
-import { Sentry } from "../utils/sentry";
-import {
-  SamsTeamsLambdaEnvironmentSchema,
-  TeamItemSchema,
-  TeamResponseSchema,
-  TeamsResponseSchema,
-} from "./types";
-
-const { logger, tracer } = createLambdaResources("sams-teams");
-const docClient = createDynamoDocClient(tracer);
-
-const env = parseLambdaEnv(SamsTeamsLambdaEnvironmentSchema);
-const TABLE_NAME = env.SAMS_TABLE_NAME;
-const SAMS_API_KEY = env.SAMS_API_KEY;
-const samsEntities = createSamsDb(docClient, TABLE_NAME);
-
-const lambdaHandler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
-  logger.appendKeys({ path: event.path });
-  logger.info("Getting SAMS teams", { pathParameters: event.pathParameters });
-  try {
-    if (!SAMS_API_KEY) {
-      console.error("SAMS API key not configured");
-      return {
-        statusCode: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "no-cache",
-        },
-        body: JSON.stringify({ error: "Server configuration error." }),
-      };
-    }
-
-    const { uuid } = event.pathParameters || {};
-    const { name } = event.queryStringParameters || {};
-
-    // Case 1: Get team by UUID (path parameter)
-    if (uuid) {
-      const result = await samsEntities.team.get({ uuid }).go();
-
-      if (!result.data) {
-        console.log(`🔍 Fetching team by UUID: ${uuid}`);
-        const { data } = await getTeamByUuid({
-          path: { uuid },
-          headers: {
-            "X-API-Key": SAMS_API_KEY,
-          },
-        });
-        if (data) {
-          // Parse with TeamItemSchema, then convert to response format
-          const freshTeam = TeamItemSchema.parse(data);
-          const responseTeam = TeamResponseSchema.parse(freshTeam);
-          return {
-            statusCode: 200,
-            headers: {
-              "Content-Type": "application/json",
-              "Cache-Control": "public, max-age=43200",
-            },
-            body: JSON.stringify(responseTeam),
-          };
-        }
-
-        return {
-          statusCode: 404,
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ error: "Team not found" }),
-        };
-      }
-
-      // Parse with TeamItemSchema, then convert to response format
-      const team = TeamItemSchema.parse(result.data);
-      const responseTeam = TeamResponseSchema.parse(team);
-
-      return {
-        statusCode: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Cache-Control": "public, max-age=43200",
-        },
-        body: JSON.stringify(responseTeam),
-      };
-    }
-
-    // Case 2: Query teams by filters (or all teams if no filter provided)
-    let teams: unknown[] = [];
-
-    if (name) {
-      // Query by name using nameSlug GSI (case-insensitive)
-      const slugifiedName = slugify(name);
-      console.log(`🔍 Querying team by nameSlug: ${name} (slug: ${slugifiedName})`);
-      const result = await samsEntities.team.query
-        .byType({ type: "team" })
-        .begins({ nameSlug: slugifiedName })
-        .go({ pages: "all" });
-      // Prefer exact nameSlug matches; fall back to all prefix matches if none are exact
-      const exactMatches = result.data.filter((t) => t.nameSlug === slugifiedName);
-      teams = exactMatches.length > 0 ? exactMatches : result.data;
-    } else {
-      // No filters provided - return all teams (since we only store our club's teams)
-      const result = await samsEntities.team.query.byType({ type: "team" }).go({ pages: "all" });
-      teams = result.data;
-    }
-
-    // Parse and validate response
-    const response = TeamsResponseSchema.parse({ teams });
-
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json",
-        "Cache-Control": "public, max-age=43200",
-      },
-      body: JSON.stringify(response),
-    };
-  } catch (error) {
-    logger.error("Error querying teams:", { error });
-    return {
-      statusCode: 500,
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ error: "Internal server error" }),
-    };
-  }
-};
-
-export const handler = Sentry.wrapHandler(
-  middy(lambdaHandler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)),
-);
diff --git a/lib/construct/vcm-nodejs-function.test.ts b/lib/construct/vcm-nodejs-function.test.ts
index 18288117c..3720fae11 100644
--- a/lib/construct/vcm-nodejs-function.test.ts
+++ b/lib/construct/vcm-nodejs-function.test.ts
@@ -10,7 +10,7 @@ function createTemplate(props?: Partial<ConstructorParameters<typeof VcmNodejsFu
   new VcmNodejsFunction(stack, "TestFn", {
     namespace: "sams",
     name: "my-func",
-    entry: "lambda/sams/sams-clubs.ts",
+    entry: "lambda/sams/sams-clubs-sync.ts",
     ...props,
   });
   return Template.fromStack(stack);
@@ -127,7 +127,7 @@ describe("VcmNodejsFunction", () => {
         new VcmNodejsFunction(stack, "TestFn", {
           namespace: "sams",
           name: "my-func",
-          entry: "lambda/sams/sams-clubs.ts",
+          entry: "lambda/sams/sams-clubs-sync.ts",
           bundling: {
             externalModules: ["@aws-sdk/*", "some-extra-module"],
           },
diff --git a/lib/sams/club-resolution.test.ts b/lib/sams/club-resolution.test.ts
new file mode 100644
index 000000000..07269b935
--- /dev/null
+++ b/lib/sams/club-resolution.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vite-plus/test";
+import {
+  filterConfiguredSamsClubs,
+  findMissingConfiguredClubSlugs,
+  resolveConfiguredSamsClubsFromRecords,
+  resolveConfiguredSportsclubUuidsFromClubs,
+} from "@/lib/sams/club-resolution";
+
+describe("findMissingConfiguredClubSlugs", () => {
+  it("returns slugs with no matching club record", () => {
+    const missing = findMissingConfiguredClubSlugs([
+      { nameSlug: "vc-muellheim", sportsclubUuid: "uuid-a" },
+    ]);
+    expect(missing).toContain("markgraefler-volleys");
+    expect(missing).not.toContain("vc-muellheim");
+  });
+});
+
+describe("resolveConfiguredSportsclubUuidsFromClubs", () => {
+  it("returns UUIDs and missing configured slugs", () => {
+    const result = resolveConfiguredSportsclubUuidsFromClubs([
+      { nameSlug: "vc-muellheim", sportsclubUuid: "uuid-a" },
+    ]);
+
+    expect(result.sportsclubUuids).toEqual(["uuid-a"]);
+    expect(result.missingClubSlugs).toContain("markgraefler-volleys");
+  });
+});
+
+describe("resolveConfiguredSamsClubsFromRecords", () => {
+  it("returns filtered clubs, UUIDs, and missing slugs from a storage snapshot", () => {
+    const result = resolveConfiguredSamsClubsFromRecords([
+      { nameSlug: "vc-muellheim", sportsclubUuid: "uuid-a" },
+    ]);
+
+    expect(result.sportsclubUuids).toEqual(["uuid-a"]);
+    expect(result.configuredClubs).toHaveLength(1);
+    expect(result.missingClubSlugs).toContain("markgraefler-volleys");
+  });
+});
+
+describe("filterConfiguredSamsClubs", () => {
+  it("keeps only configured target clubs with a sportsclub UUID", () => {
+    const filtered = filterConfiguredSamsClubs([
+      { nameSlug: "vc-muellheim", sportsclubUuid: "uuid-a", name: "VC Müllheim" },
+      { nameSlug: "other-club", sportsclubUuid: "uuid-b", name: "Other" },
+      { nameSlug: "markgraefler-volleys", sportsclubUuid: "uuid-c", name: "Markgräfler Volleys" },
+    ]);
+
+    expect(filtered.map((c) => c.nameSlug).sort()).toEqual([
+      "markgraefler-volleys",
+      "vc-muellheim",
+    ]);
+  });
+});
diff --git a/lib/sams/club-resolution.ts b/lib/sams/club-resolution.ts
new file mode 100644
index 000000000..264222f84
--- /dev/null
+++ b/lib/sams/club-resolution.ts
@@ -0,0 +1,54 @@
+import {
+  resolveConfiguredSamsSportsclubUuids,
+  resolveSamsClubSlug,
+  SAMS_TARGET_CLUB_SLUGS,
+} from "@utils/sams";
+
+export type SamsClubRecord = {
+  nameSlug?: string | null;
+  name?: string | null;
+  sportsclubUuid?: string | null;
+  associationUuid?: string | null;
+};
+
+/** Slugs from project config that have no matching club record in storage. */
+export function findMissingConfiguredClubSlugs(clubs: readonly SamsClubRecord[]): string[] {
+  return SAMS_TARGET_CLUB_SLUGS.filter(
+    (clubSlug) =>
+      !clubs.some((club) => resolveSamsClubSlug(club) === clubSlug && !!club.sportsclubUuid),
+  );
+}
+
+/** Keeps only clubs that match configured target slugs and have a sportsclub UUID. */
+export function filterConfiguredSamsClubs<T extends SamsClubRecord>(clubs: readonly T[]): T[] {
+  const sportsclubUuids = new Set(resolveConfiguredSamsSportsclubUuids(clubs));
+  return clubs.filter(
+    (club): club is T => !!club.sportsclubUuid && sportsclubUuids.has(club.sportsclubUuid),
+  );
+}
+
+/** Resolves configured clubs from a storage snapshot (no I/O). */
+export function resolveConfiguredSamsClubsFromRecords(clubs: readonly SamsClubRecord[]): {
+  configuredClubs: SamsClubRecord[];
+  sportsclubUuids: string[];
+  missingClubSlugs: string[];
+} {
+  const missingClubSlugs = findMissingConfiguredClubSlugs(clubs);
+  return {
+    configuredClubs: filterConfiguredSamsClubs(clubs),
+    sportsclubUuids: resolveConfiguredSamsSportsclubUuids(clubs),
+    missingClubSlugs,
+  };
+}
+
+/** Resolves configured sportsclub UUIDs and reports missing target slugs. */
+export function resolveConfiguredSportsclubUuidsFromClubs(clubs: readonly SamsClubRecord[]): {
+  sportsclubUuids: string[];
+  missingClubSlugs: string[];
+} {
+  const resolved = resolveConfiguredSamsClubsFromRecords(clubs);
+  return {
+    sportsclubUuids: resolved.sportsclubUuids,
+    missingClubSlugs: resolved.missingClubSlugs,
+  };
+}
diff --git a/lib/sams/roster-mapping.test.ts b/lib/sams/roster-mapping.test.ts
new file mode 100644
index 000000000..e31c64d2b
--- /dev/null
+++ b/lib/sams/roster-mapping.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vite-plus/test";
+import { mapRosterOfficials, mapRosterPlayers, pseudoRosterUuid } from "@/lib/sams/roster-mapping";
+
+describe("pseudoRosterUuid", () => {
+  it("derives stable UUIDs from team and field data", () => {
+    const first = pseudoRosterUuid("team-1", "player", "Max Mustermann", 7);
+    const second = pseudoRosterUuid("team-1", "player", "Max Mustermann", 7);
+    const different = pseudoRosterUuid("team-1", "player", "Max Mustermann", 8);
+
+    expect(first).toBe(second);
+    expect(first).not.toBe(different);
+    expect(first).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  });
+});
+
+describe("mapRosterPlayers", () => {
+  it("filters empty names and fills missing API uuids", () => {
+    const players = mapRosterPlayers("team-1", [
+      { name: "  ", uuid: "skip-me" },
+      { name: "Anna Becker", jerseyNumber: 12 },
+    ]);
+
+    expect(players).toHaveLength(1);
+    expect(players[0]?.name).toBe("Anna Becker");
+    expect(players[0]?.jerseyNumber).toBe(12);
+    expect(players[0]?.uuid).toBeTruthy();
+  });
+});
+
+describe("mapRosterOfficials", () => {
+  it("maps officials with optional roles", () => {
+    const officials = mapRosterOfficials("team-1", [{ name: "Coach Name", role: "Trainer" }]);
+    expect(officials).toEqual([expect.objectContaining({ name: "Coach Name", role: "Trainer" })]);
+  });
+});
diff --git a/lib/sams/roster-mapping.ts b/lib/sams/roster-mapping.ts
new file mode 100644
index 000000000..890f98a36
--- /dev/null
+++ b/lib/sams/roster-mapping.ts
@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import type { RosterOfficial, RosterPlayer } from "@/lambda/sams/types";
+
+export function pseudoRosterUuid(
+  teamUuid: string,
+  kind: "player" | "official",
+  ...parts: (string | number | undefined)[]
+): string {
+  const input = [teamUuid, kind, ...parts.map((part) => String(part ?? ""))].join("|");
+  const hex = createHash("sha256").update(input).digest("hex").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+
+export function mapRosterPlayers(
+  teamUuid: string,
+  players: Array<{
+    uuid?: string;
+    name?: string | null;
+    jerseyNumber?: number | null;
+    position?: string | null;
+    portraitImageLink?: string | null;
+  }> = [],
+): RosterPlayer[] {
+  return players
+    .filter((p): p is typeof p & { name: string } => !!p.name?.trim())
+    .map((p) => ({
+      uuid: p.uuid ?? pseudoRosterUuid(teamUuid, "player", p.name, p.jerseyNumber ?? undefined),
+      name: p.name,
+      ...(p.jerseyNumber != null ? { jerseyNumber: p.jerseyNumber } : {}),
+      ...(p.position ? { position: p.position } : {}),
+      ...(p.portraitImageLink ? { portraitImageLink: p.portraitImageLink } : {}),
+    }));
+}
+
+export function mapRosterOfficials(
+  teamUuid: string,
+  officials: Array<{
+    uuid?: string;
+    name?: string | null;
+    role?: string | null;
+  }> = [],
+): RosterOfficial[] {
+  return officials
+    .filter((o): o is typeof o & { name: string } => !!o.name?.trim())
+    .map((o) => ({
+      uuid: o.uuid ?? pseudoRosterUuid(teamUuid, "official", o.name, o.role ?? undefined),
+      name: o.name,
+      ...(o.role ? { role: o.role } : {}),
+    }));
+}
diff --git a/lib/sams/teams-sync-service.test.ts b/lib/sams/teams-sync-service.test.ts
new file mode 100644
index 000000000..543723499
--- /dev/null
+++ b/lib/sams/teams-sync-service.test.ts
@@ -0,0 +1,70 @@
+import type { SeasonDto } from "@codegen/sams/generated";
+import { describe, expect, it, vi } from "vite-plus/test";
+import { buildSyncedTeamItem, fetchCurrentSeasonUuid } from "@/lib/sams/teams-sync-service";
+
+vi.mock("@codegen/sams/generated", () => ({
+  getAllSeasons: vi.fn(),
+  getAllLeagueHierarchies: vi.fn(),
+  getAllLeagues: vi.fn(),
+  getTeamRosterByTeamUuid: vi.fn(),
+  getTeamsForLeague: vi.fn(),
+}));
+
+import { getAllSeasons } from "@codegen/sams/generated";
+
+const mockGetAllSeasons = vi.mocked(getAllSeasons);
+
+function mockSeasonsResponse(seasons: SeasonDto[]) {
+  mockGetAllSeasons.mockImplementation(async () => ({
+    data: seasons,
+    request: new Request("https://example.com/seasons"),
+    response: new Response(),
+  }));
+}
+
+describe("fetchCurrentSeasonUuid", () => {
+  it("returns the season marked as current", async () => {
+    mockSeasonsResponse([
+      { uuid: "old", name: "2024/25", currentSeason: false },
+      { uuid: "current", name: "2025/26", currentSeason: true },
+    ]);
+
+    await expect(fetchCurrentSeasonUuid()).resolves.toEqual({
+      uuid: "current",
+      name: "2025/26",
+    });
+  });
+
+  it("throws when no current season exists", async () => {
+    mockSeasonsResponse([{ uuid: "old", name: "2024/25", currentSeason: false }]);
+
+    await expect(fetchCurrentSeasonUuid()).rejects.toThrow("Current season not found");
+  });
+});
+
+describe("buildSyncedTeamItem", () => {
+  it("maps API team fields into a synced team record", () => {
+    const team = buildSyncedTeamItem(
+      {
+        uuid: "team-1",
+        name: "VC Müllheim",
+        sportsclubUuid: "club-1",
+        associationUuid: "assoc-1",
+      },
+      { uuid: "league-1", name: "Bezirksliga", leagueHierarchyUuid: "hier-1" },
+      { uuid: "season-1", name: "2025/26" },
+      new Map([["hier-1", 3]]),
+      "2026-07-21T10:00:00.000Z",
+      1_700_000_000,
+    );
+
+    expect(team).toMatchObject({
+      uuid: "team-1",
+      name: "VC Müllheim",
+      nameSlug: "vc-muellheim",
+      leagueHierarchyLevel: 3,
+      seasonUuid: "season-1",
+      ttl: 1_700_000_000,
+    });
+  });
+});
diff --git a/lib/sams/teams-sync-service.ts b/lib/sams/teams-sync-service.ts
new file mode 100644
index 000000000..6d274883a
--- /dev/null
+++ b/lib/sams/teams-sync-service.ts
@@ -0,0 +1,419 @@
+/**
+ * SAMS teams sync — orchestrates club resolution, live season fetch, league/team/roster
+ * pagination, DynamoDB upserts, and stale record deletion.
+ *
+ * Sync writes **live** currentSeason to team records; match loading reads that synced
+ * seasonUuid — see docs/adr/0001-sams-match-loading.md.
+ */
+
+import {
+  getAllLeagueHierarchies,
+  getAllLeagues,
+  getAllSeasons,
+  getTeamRosterByTeamUuid,
+  getTeamsForLeague,
+} from "@codegen/sams/generated";
+import { slugify } from "@utils/slugify";
+import dayjs from "dayjs";
+import type { createSamsDb } from "@/lib/db/electrodb-client";
+import {
+  resolveConfiguredSamsClubsFromRecords,
+  type SamsClubRecord,
+} from "@/lib/sams/club-resolution";
+import { mapRosterOfficials, mapRosterPlayers } from "@/lib/sams/roster-mapping";
+
+type SamsDb = ReturnType<typeof createSamsDb>;
+
+export type SyncedTeamItem = {
+  uuid: string;
+  type: "team";
+  name: string;
+  nameSlug: string;
+  sportsclubUuid: string;
+  associationUuid: string;
+  leagueUuid: string;
+  leagueName: string;
+  leagueHierarchyLevel?: number;
+  seasonUuid: string;
+  seasonName: string;
+  updatedAt: string;
+  ttl: number;
+};
+
+export type SyncedRosterItem = {
+  teamUuid: string;
+  type: "roster";
+  players: ReturnType<typeof mapRosterPlayers>;
+  officials: ReturnType<typeof mapRosterOfficials>;
+  updatedAt: string;
+  ttl: number;
+};
+
+export type TeamsSyncResult = {
+  success: true;
+  teamsProcessed: number;
+  teamsDeleted: number;
+  rostersProcessed: number;
+  rostersFailed: number;
+  timestamp: string;
+};
+
+export type TeamsSyncLogger = {
+  info: (message: string, meta?: Record<string, unknown>) => void;
+  warn: (message: string, meta?: Record<string, unknown>) => void;
+};
+
+export type TeamsSyncContext = {
+  samsEntities: SamsDb;
+  logger: TeamsSyncLogger;
+  rateLimitMs?: number;
+  onTeamsFound?: (count: number, byClub: Record<string, number>) => void;
+  onComplete?: (result: TeamsSyncResult) => void;
+  captureRosterError?: (error: unknown, team: SyncedTeamItem) => void;
+};
+
+const DEFAULT_RATE_LIMIT_MS = 500;
+const TEAM_TTL_SECONDS = 60 * 60 * 24 * 365;
+
+async function delay(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+type SamsLeagueDto = {
+  uuid?: string;
+  name?: string | null;
+  seasonUuid?: string;
+  leagueHierarchyUuid?: string;
+};
+
+type SamsTeamDto = {
+  masterTeamUuid?: string | null;
+  sportsclubUuid?: string | null;
+  uuid?: string;
+  name?: string | null;
+  associationUuid?: string | null;
+};
+
+function isCurrentSeasonLeague(
+  league: SamsLeagueDto,
+  seasonUuid: string,
+): league is SamsLeagueDto & { uuid: string; name: string } {
+  return league.seasonUuid === seasonUuid && !!league.uuid && !!league.name;
+}
+
+function isSyncableTeam(
+  team: SamsTeamDto,
+  sportsclubUuids: Set<string>,
+): team is SamsTeamDto & {
+  uuid: string;
+  name: string;
+  sportsclubUuid: string;
+  associationUuid: string;
+} {
+  return (
+    !team.masterTeamUuid &&
+    !!team.sportsclubUuid &&
+    sportsclubUuids.has(team.sportsclubUuid) &&
+    !!team.uuid &&
+    !!team.name &&
+    !!team.associationUuid
+  );
+}
+
+export function buildSyncedTeamItem(
+  team: SamsTeamDto & {
+    uuid: string;
+    name: string;
+    sportsclubUuid: string;
+    associationUuid: string;
+  },
+  league: { uuid: string; name: string; leagueHierarchyUuid?: string },
+  season: { uuid: string; name: string },
+  hierarchyLevelByUuid: Map<string, number>,
+  nowIso: string,
+  ttl: number,
+): SyncedTeamItem {
+  const leagueHierarchyLevel = league.leagueHierarchyUuid
+    ? hierarchyLevelByUuid.get(league.leagueHierarchyUuid)
+    : undefined;
+
+  return {
+    uuid: team.uuid,
+    type: "team",
+    name: team.name,
+    nameSlug: slugify(team.name),
+    sportsclubUuid: team.sportsclubUuid,
+    associationUuid: team.associationUuid,
+    leagueUuid: league.uuid,
+    leagueName: league.name,
+    ...(leagueHierarchyLevel !== undefined ? { leagueHierarchyLevel } : {}),
+    seasonUuid: season.uuid,
+    seasonName: season.name,
+    updatedAt: nowIso,
+    ttl,
+  };
+}
+
+export async function resolveConfiguredSamsClubsFromStorage(
+  samsEntities: SamsDb,
+  logger: TeamsSyncLogger,
+): Promise<SamsClubRecord[]> {
+  const clubResponse = await samsEntities.club.query.byType({ type: "club" }).go({ pages: "all" });
+  const { configuredClubs, missingClubSlugs } = resolveConfiguredSamsClubsFromRecords(
+    clubResponse.data,
+  );
+
+  if (missingClubSlugs.length > 0) {
+    logger.warn("Failed to resolve configured SAMS clubs", { missingClubSlugs });
+  }
+
+  return configuredClubs;
+}
+
+export async function fetchCurrentSeasonUuid(): Promise<{ uuid: string; name: string }> {
+  const { data: seasons } = await getAllSeasons({});
+  const currentSeason = seasons?.find((s) => s.currentSeason);
+  if (!currentSeason?.uuid || !currentSeason.name) {
+    throw new Error("Current season not found or missing uuid/name");
+  }
+  return { uuid: currentSeason.uuid, name: currentSeason.name };
+}
+
+async function fetchLeaguesForAssociations(
+  associationUuids: string[],
+  seasonUuid: string,
+  rateLimitMs: number,
+): Promise<{
+  leagues: Array<{ uuid: string; name: string; seasonUuid?: string; leagueHierarchyUuid?: string }>;
+  hierarchyLevelByUuid: Map<string, number>;
+}> {
+  const allLeagues: Array<{
+    uuid: string;
+    name: string;
+    seasonUuid?: string;
+    leagueHierarchyUuid?: string;
+  }> = [];
+  const hierarchyLevelByUuid = new Map<string, number>();
+
+  for (const associationUuid of associationUuids) {
+    let hierarchyPage = 0;
+    let hasMoreHierarchies = true;
+    while (hasMoreHierarchies) {
+      const { data: hierarchyData } = await getAllLeagueHierarchies({
+        query: {
+          association: associationUuid,
+          "for-season": seasonUuid,
+          page: hierarchyPage,
+          size: 100,
+        },
+      });
+      for (const hierarchy of hierarchyData?.content ?? []) {
+        if (hierarchy.uuid && hierarchy.level !== undefined) {
+          hierarchyLevelByUuid.set(hierarchy.uuid, hierarchy.level);
+        }
+      }
+      hasMoreHierarchies = hierarchyData?.last !== true;
+      hierarchyPage++;
+    }
+
+    let leaguePage = 0;
+    let hasMoreLeagues = true;
+    while (hasMoreLeagues) {
+      const { data: leagueData } = await getAllLeagues({
+        query: {
+          association: associationUuid,
+          page: leaguePage,
+          size: 100,
+        },
+      });
+
+      if (leagueData?.content) {
+        const currentSeasonLeagues = leagueData.content.filter((league) =>
+          isCurrentSeasonLeague(league, seasonUuid),
+        );
+        allLeagues.push(...currentSeasonLeagues);
+        leaguePage++;
+      }
+
+      if (leagueData?.last === true) {
+        hasMoreLeagues = false;
+      }
+
+      await delay(rateLimitMs);
+    }
+  }
+
+  return { leagues: allLeagues, hierarchyLevelByUuid };
+}
+
+async function fetchTeamsForLeagues(
+  leagues: Array<{ uuid: string; name: string; leagueHierarchyUuid?: string }>,
+  sportsclubUuids: Set<string>,
+  season: { uuid: string; name: string },
+  hierarchyLevelByUuid: Map<string, number>,
+  rateLimitMs: number,
+): Promise<SyncedTeamItem[]> {
+  const allTeams: SyncedTeamItem[] = [];
+  const nowIso = dayjs().toISOString();
+  const ttl = dayjs().unix() + TEAM_TTL_SECONDS;
+
+  for (const league of leagues) {
+    let teamPage = 0;
+    let hasMoreTeams = true;
+
+    while (hasMoreTeams) {
+      const { data: teamData } = await getTeamsForLeague({
+        path: { uuid: league.uuid },
+        query: { page: teamPage, size: 100 },
+      });
+
+      if (teamData?.content) {
+        const ourTeams = teamData.content
+          .filter((team) => isSyncableTeam(team, sportsclubUuids))
+          .map((team) =>
+            buildSyncedTeamItem(team, league, season, hierarchyLevelByUuid, nowIso, ttl),
+          );
+
+        allTeams.push(...ourTeams);
+        teamPage++;
+      }
+
+      if (teamData?.last === true) {
+        hasMoreTeams = false;
+      }
+
+      await delay(rateLimitMs);
+    }
+  }
+
+  return allTeams;
+}
+
+async function upsertTeamsAndRosters(
+  samsEntities: SamsDb,
+  teams: SyncedTeamItem[],
+  rateLimitMs: number,
+  captureRosterError?: (error: unknown, team: SyncedTeamItem) => void,
+): Promise<{ rostersProcessed: number; rostersFailed: number }> {
+  let rostersProcessed = 0;
+  let rostersFailed = 0;
+
+  for (const team of teams) {
+    await samsEntities.team.upsert(team).go();
+
+    try {
+      const { data: rosterData, error: rosterError } = await getTeamRosterByTeamUuid({
+        path: { uuid: team.uuid },
+      });
+      if (rosterError) {
+        throw rosterError;
+      }
+      if (rosterData) {
+        const rosterItem: SyncedRosterItem = {
+          teamUuid: team.uuid,
+          type: "roster",
+          players: mapRosterPlayers(team.uuid, rosterData.players),
+          officials: mapRosterOfficials(team.uuid, rosterData.officials),
+          updatedAt: dayjs().toISOString(),
+          ttl: dayjs().unix() + TEAM_TTL_SECONDS,
+        };
+        await samsEntities.roster.upsert(rosterItem).go();
+        rostersProcessed++;
+      }
+    } catch (error) {
+      captureRosterError?.(error, team);
+      await samsEntities.roster
+        .delete({ teamUuid: team.uuid })
+        .go()
+        .catch(() => undefined);
+      rostersFailed++;
+    }
+
+    await delay(rateLimitMs);
+  }
+
+  return { rostersProcessed, rostersFailed };
+}
+
+async function deleteStaleTeams(samsEntities: SamsDb): Promise<number> {
+  const oneHourAgo = dayjs().subtract(1, "hour").toISOString();
+  const existingResponse = await samsEntities.team.query
+    .byType({ type: "team" })
+    .go({ pages: "all" });
+  let teamsDeleted = 0;
+
+  for (const existingTeam of existingResponse.data) {
+    if (existingTeam.updatedAt < oneHourAgo) {
+      await samsEntities.team.delete({ uuid: existingTeam.uuid }).go();
+      await samsEntities.roster.delete({ teamUuid: existingTeam.uuid }).go();
+      teamsDeleted++;
+    }
+  }
+
+  return teamsDeleted;
+}
+
+export async function runSamsTeamsSync(ctx: TeamsSyncContext): Promise<TeamsSyncResult> {
+  const { samsEntities, logger } = ctx;
+  const rateLimitMs = ctx.rateLimitMs ?? DEFAULT_RATE_LIMIT_MS;
+
+  const clubs = await resolveConfiguredSamsClubsFromStorage(samsEntities, logger);
+  if (clubs.length === 0) {
+    throw new Error("No configured SAMS clubs found in DynamoDB");
+  }
+
+  const sportsclubUuids = new Set(
+    clubs.flatMap((club) => (club.sportsclubUuid ? [club.sportsclubUuid] : [])),
+  );
+  const associationUuids = [
+    ...new Set(clubs.flatMap((club) => (club.associationUuid ? [club.associationUuid] : []))),
+  ];
+
+  if (associationUuids.length === 0) {
+    throw new Error("Configured SAMS clubs have no associationUuid — cannot fetch leagues");
+  }
+
+  const currentSeason = await fetchCurrentSeasonUuid();
+  const { leagues, hierarchyLevelByUuid } = await fetchLeaguesForAssociations(
+    associationUuids,
+    currentSeason.uuid,
+    rateLimitMs,
+  );
+
+  const allTeams = await fetchTeamsForLeagues(
+    leagues,
+    sportsclubUuids,
+    currentSeason,
+    hierarchyLevelByUuid,
+    rateLimitMs,
+  );
+
+  const teamsBySportsclubUuid = Object.fromEntries(
+    [...sportsclubUuids].map((sportsclubUuid) => [
+      sportsclubUuid,
+      allTeams.filter((team) => team.sportsclubUuid === sportsclubUuid).length,
+    ]),
+  );
+  ctx.onTeamsFound?.(allTeams.length, teamsBySportsclubUuid);
+
+  const { rostersProcessed, rostersFailed } = await upsertTeamsAndRosters(
+    samsEntities,
+    allTeams,
+    rateLimitMs,
+    ctx.captureRosterError,
+  );
+
+  const teamsDeleted = await deleteStaleTeams(samsEntities);
+
+  const result: TeamsSyncResult = {
+    success: true,
+    teamsProcessed: allTeams.length,
+    teamsDeleted,
+    rostersProcessed,
+    rostersFailed,
+    timestamp: dayjs().toISOString(),
+  };
+
+  ctx.onComplete?.(result);
+  return result;
+}
diff --git a/utils/sams-api.ts b/utils/sams-api.ts
new file mode 100644
index 000000000..109b038fd
--- /dev/null
+++ b/utils/sams-api.ts
@@ -0,0 +1,5 @@
+/** Shared SAMS HTTP client timeout for webapp server functions and match loading. */
+export const SAMS_API_TIMEOUT_MS = 10_000;
+
+/** DynamoDB match cache TTL — keep useSamsMatches staleTime aligned with this. */
+export const SAMS_MATCHES_CACHE_TTL_MS = 5 * 60 * 1000;
diff --git a/utils/sams-match-filter.test.ts b/utils/sams-match-filter.test.ts
new file mode 100644
index 000000000..a60dd0fff
--- /dev/null
+++ b/utils/sams-match-filter.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vite-plus/test";
+import { filterAndSortSamsMatches } from "@/utils/sams-match-filter";
+
+describe("filterAndSortSamsMatches", () => {
+  const matches = [
+    { uuid: "1", date: "2026-01-10", results: { winner: "a" } },
+    { uuid: "2", date: "2026-01-05", results: { winner: "b" } },
+    { uuid: "3", date: "2026-02-01", results: null },
+    { uuid: "4", date: "2026-01-20", results: null },
+  ];
+
+  it("keeps completed matches newest-first for past range", () => {
+    const result = filterAndSortSamsMatches(matches, { range: "past" });
+    expect(result.map((m) => m.uuid)).toEqual(["1", "2"]);
+  });
+
+  it("keeps unplayed matches oldest-first for future range", () => {
+    const result = filterAndSortSamsMatches(matches, { range: "future" });
+    expect(result.map((m) => m.uuid)).toEqual(["4", "3"]);
+  });
+
+  it("applies limit after range filtering", () => {
+    const result = filterAndSortSamsMatches(matches, { range: "future", limit: 1 });
+    expect(result).toHaveLength(1);
+    expect(result[0]?.uuid).toBe("4");
+  });
+});
diff --git a/utils/sams-match-filter.ts b/utils/sams-match-filter.ts
new file mode 100644
index 000000000..020e9026c
--- /dev/null
+++ b/utils/sams-match-filter.ts
@@ -0,0 +1,45 @@
+import dayjs from "dayjs";
+import type { SamsMatchesInput } from "@utils/sams-matches";
+
+export type SamsMatchFilterInput = Pick<SamsMatchesInput, "range" | "limit">;
+
+type MatchWithResult = {
+  date?: string | null;
+  results?: { winner?: string | null } | null;
+};
+
+function compareMatchDates(a: MatchWithResult, b: MatchWithResult, ascending: boolean): number {
+  if (!a.date) return 1;
+  if (!b.date) return -1;
+  const aDate = dayjs(a.date);
+  const bDate = dayjs(b.date);
+  if (aDate.isSame(bDate)) return 0;
+  return ascending ? (aDate.isBefore(bDate) ? -1 : 1) : aDate.isAfter(bDate) ? -1 : 1;
+}
+
+function filterAndSortByRange<T extends MatchWithResult>(
+  matches: readonly T[],
+  range: "past" | "future",
+): T[] {
+  const filtered =
+    range === "future"
+      ? matches.filter((m) => !m.results?.winner)
+      : matches.filter((m) => !!m.results?.winner);
+  return [...filtered].sort((a, b) => compareMatchDates(a, b, range === "future"));
+}
+
+/** Post-fetch range/limit filtering for SAMS league matches (after API pagination). */
+export function filterAndSortSamsMatches<T extends MatchWithResult>(
+  allMatches: readonly T[],
+  input?: SamsMatchFilterInput,
+): T[] {
+  let filteredMatches = [...allMatches];
+  if (input?.range === "future") {
+    filteredMatches = filterAndSortByRange(allMatches, "future");
+  } else if (input?.range === "past") {
+    filteredMatches = filterAndSortByRange(allMatches, "past");
+  }
+
+  if (input?.limit) filteredMatches = filteredMatches.slice(0, input.limit);
+  return filteredMatches;
+}
diff --git a/utils/sams-matches.ts b/utils/sams-matches.ts
new file mode 100644
index 000000000..7818c9438
--- /dev/null
+++ b/utils/sams-matches.ts
@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export const samsMatchesQuerySchema = z.object({
+  league: z.string().optional(),
+  season: z.string().optional(),
+  sportsclub: z.string().optional(),
+  team: z.string().optional(),
+  limit: z.number().int().positive().optional(),
+  range: z.enum(["past", "future"]).optional(),
+});
+
+export type SamsMatchesInput = z.infer<typeof samsMatchesQuerySchema>;
+
+/** Optional wrapper for createServerFn validators. */
+export const samsMatchesInputSchema = samsMatchesQuerySchema.optional();
diff --git a/utils/sams.test.ts b/utils/sams.test.ts
index 6b1c4103d..7eadf4623 100644
--- a/utils/sams.test.ts
+++ b/utils/sams.test.ts
@@ -1,9 +1,10 @@
-import { describe, expect, it } from "vite-plus/test";
+import { describe, expect, it, vi } from "vite-plus/test";
 import {
   dedupeSamsMatchesByUuid,
   getOwnedSamsSportsclubUuids,
   getOwnedSamsTeamUuids,
   resolveConfiguredSamsSportsclubUuids,
+  resolveSyncedSeasonUuidFromTeams,
   shouldResolveDefaultSamsSportsclubs,
 } from "./sams";
 
@@ -29,6 +30,45 @@ describe("shouldResolveDefaultSamsSportsclubs", () => {
   });
 });
 
+describe("resolveSyncedSeasonUuidFromTeams", () => {
+  it("returns the unanimous season UUID when all teams agree", () => {
+    expect(
+      resolveSyncedSeasonUuidFromTeams([{ seasonUuid: "season-a" }, { seasonUuid: "season-a" }]),
+    ).toBe("season-a");
+  });
+
+  it("returns the majority season UUID", () => {
+    expect(
+      resolveSyncedSeasonUuidFromTeams([
+        { seasonUuid: "season-a" },
+        { seasonUuid: "season-a" },
+        { seasonUuid: "season-b" },
+      ]),
+    ).toBe("season-a");
+  });
+
+  it("breaks ties by most recently updated team", () => {
+    expect(
+      resolveSyncedSeasonUuidFromTeams([
+        { seasonUuid: "season-a", updatedAt: "2026-01-01T00:00:00.000Z" },
+        { seasonUuid: "season-b", updatedAt: "2026-02-01T00:00:00.000Z" },
+      ]),
+    ).toBe("season-b");
+  });
+
+  it("calls onDisagreement when multiple seasons are present", () => {
+    const onDisagreement = vi.fn();
+    resolveSyncedSeasonUuidFromTeams([{ seasonUuid: "season-a" }, { seasonUuid: "season-b" }], {
+      onDisagreement,
+    });
+    expect(onDisagreement).toHaveBeenCalledWith(["season-a", "season-b"]);
+  });
+
+  it("returns undefined when no team has a season UUID", () => {
+    expect(resolveSyncedSeasonUuidFromTeams([{}, { seasonUuid: null }])).toBeUndefined();
+  });
+});
+
 describe("owned SAMS UUID helpers", () => {
   it("derives team and sportsclub ownership sets from UUIDs", () => {
     const teams = [
diff --git a/utils/sams.ts b/utils/sams.ts
index a1cd54446..726f94bce 100644
--- a/utils/sams.ts
+++ b/utils/sams.ts
@@ -5,12 +5,15 @@ type NullableString = string | null | undefined;
 
 type ClubLike = {
   nameSlug?: NullableString;
+  name?: NullableString;
   sportsclubUuid?: NullableString;
 };
 
 type TeamLike = {
   uuid?: NullableString;
   sportsclubUuid?: NullableString;
+  seasonUuid?: NullableString;
+  updatedAt?: NullableString;
 };
 
 type MatchLike = {
@@ -27,13 +30,20 @@ export function isConfiguredSamsClubSlug(nameSlug: NullableString): boolean {
   return !!nameSlug && samsTargetClubSlugSet.has(nameSlug);
 }
 
+export function resolveSamsClubSlug(club: ClubLike): string | undefined {
+  if (club.nameSlug) return club.nameSlug;
+  if (club.name) return slugify(club.name);
+  return undefined;
+}
+
 export function resolveConfiguredSamsSportsclubUuids<T extends ClubLike>(
   clubs: readonly T[],
 ): string[] {
   const sportsclubUuids = new Set<string>();
 
   for (const club of clubs) {
-    if (!club.sportsclubUuid || !isConfiguredSamsClubSlug(club.nameSlug)) continue;
+    const slug = resolveSamsClubSlug(club);
+    if (!club.sportsclubUuid || !isConfiguredSamsClubSlug(slug)) continue;
     sportsclubUuids.add(club.sportsclubUuid);
   }
 
@@ -48,6 +58,58 @@ export function shouldResolveDefaultSamsSportsclubs(filters: {
   return !filters.league && !filters.sportsclub && !filters.team;
 }
 
+export function resolveEffectiveSamsSportsclubUuids(
+  input: Pick<
+    { league?: NullableString; sportsclub?: NullableString; team?: NullableString },
+    "league" | "sportsclub" | "team"
+  >,
+  defaultSportsclubUuids: readonly string[],
+): string[] {
+  if (input.sportsclub) return [input.sportsclub];
+  if (!shouldResolveDefaultSamsSportsclubs(input)) return [];
+  return [...defaultSportsclubUuids];
+}
+
+function compareIsoTimestampsDesc(left?: NullableString, right?: NullableString): number {
+  if (!left && !right) return 0;
+  if (!left) return 1;
+  if (!right) return -1;
+  return right.localeCompare(left);
+}
+
+/** Season UUID from synced teams in DynamoDB (teams sync output), not SAMS live currentSeason. */
+export function resolveSyncedSeasonUuidFromTeams<
+  T extends Pick<TeamLike, "seasonUuid" | "updatedAt">,
+>(
+  teams: readonly T[],
+  options?: { onDisagreement?: (seasonUuids: readonly string[]) => void },
+): string | undefined {
+  const teamsWithSeason = teams.filter(
+    (team): team is T & { seasonUuid: string } => !!team.seasonUuid,
+  );
+  if (teamsWithSeason.length === 0) return undefined;
+
+  const counts = new Map<string, number>();
+  for (const team of teamsWithSeason) {
+    counts.set(team.seasonUuid, (counts.get(team.seasonUuid) ?? 0) + 1);
+  }
+
+  const distinctSeasons = [...counts.keys()];
+  if (distinctSeasons.length > 1) {
+    options?.onDisagreement?.(distinctSeasons);
+  }
+
+  const maxCount = Math.max(...counts.values());
+  const topSeasons = new Set(
+    [...counts.entries()].filter(([, count]) => count === maxCount).map(([uuid]) => uuid),
+  );
+
+  const candidates = teamsWithSeason.filter((team) => topSeasons.has(team.seasonUuid));
+  candidates.sort((left, right) => compareIsoTimestampsDesc(left.updatedAt, right.updatedAt));
+
+  return candidates[0]?.seasonUuid;
+}
+
 export function getOwnedSamsTeamUuids<T extends TeamLike>(teams: readonly T[]): Set<string> {
   const teamUuids = new Set<string>();